Bom. Variável, como o próprio nome diz, é algo que varia (dãnn). Assim temos identificadores capazes de representar conteúdos mutáveis. Elas são armazenadas em uma memória auxiliar e destruídas após a execução do programa.

No PHP é muuuito simples criar uma variável, basta atribuir um nome iniciado pelo caracter de cifrão ($). Veja o exemplo abaixo:

 <?php
$nome = 'Washington';
$sobrenome = 'Patrício';
echo $nome.' '.$sobrenome;
?> 

Simples né? Mais temos algumas regrinhas básica na nomeclatura de uma variável. Veja:

1. Nunca inicie o nome de uma variável com números.
2. Nunca utilize espaços em brancos no nome de uma variável.
3. Nunca utilize caracteres especiais (! @ # $ % ¨ & * / | [ ] { })
4. Evite criar variáveis com mais de 15 caracteres. Isso deixa mais claro e limpo teu código.
5. O nome de uma variável deve transmitir a idéia do que ela armazena. Pense bem nisso! (nada de $variavel3245)
6. Utilize preferencialmente palavras em minúsculo (separadas pelo underline _ )

 <?php
$codigo_cliente;
$codigoCliente;
?>
 

O PHP é Case Sensitive, ou seja, a variável $cliente é diferente da variável $Cliente. Tome cuidado ao declarar variáveis e nome de funções.

Em algumas situações, precisamos de um nome de variável que muda em determinada situação. Neste caso, não só o conteúdo de uma variável é mutável, mas também o seu nome. Para isso temos as Variáveis Variantes (variable variables). O processo de criação é semelhante, basta dobra o numero de cifrão ($$). O PHP irá referencia-la pelo conteúdo da primeira. Veja:

 <?php
// Define o nome da variável
$variavel = 'nome';

// Cria uma variável identificada pelo conteúdo de $variavel
$variavel = 'Washington';

// Imprime a variável $nome na tela
echo $nome;
?>
 

Bom galera por hoje é só isso! Nos próximos post vamos ver os tipos de variáveis existente e conhece-las bem a fundo! Então não perca!

No mais? testem o que foi aprendido hoje, tendo duvidas dá aquela 'tuítada' pra mim (@waapatricio) ou posta aí nos comentários que eu respondo também!

Abrss!

antes de ser iniciado o processo da Maquiagem digital é necessario que a imagem já esteja editada e retocada é necessario que espinhas sinais ou erros já estejam corrigidos, no caso abaixo usarem a maquiagem digital em mulheres que seram aplicadas simulações de blushes sombras, pó e etc...

vamos começar! , se a pele da pessoa já estiver corrigida podemos começar, vou usar a foto da atriz Emma Watson, como ela já tem uma pele belissima não foi necessario muitas correções

antes de tudo clique Aqui para fazer o download da imagem

(imagem pronta para Maquiagem digital)

vamos começar!

primeiro vamos fazer um leve retoque na pele:

copie a camada da foto e reenomeie como "retoque pele"

essa será a nossa pele retocada, após copiar com a camada selecionada vá em filter /blur /surface blur

na caixa de configurações que apareçe altere-a como abaixo:

esta configuração funciona para o tipo de pele como o de Emma dependendo da pele da pessoa vá aumentando o Radius

depois de ter ajustado clique em ok para aplicar

agora vamos alterar a tonalização da pele e dar um leve contraste faça como abaixo

vá em image / adjustments / curves deixe o gráfico como no exemplo abaixo:

(clique e arraste os pontos pretos do grafico para modifica-lo)

agora vamos ajustar a saturação

vá em image / adjustments / hue e saturation em hue deixe em -6 

agora clique no icone add layer mask (mascara de camada)

agora perçeba que surgiu um novo icone de visualização ao lado do da imagem

este quadro branco é a sua mascara de camada ela funciona como um tipo de camada particular pra cada imagem

mantenha a mascara de camada selecionada depois selecione a cor preta e usando a paint bucket tool clique em cima da imagem 

perceba que a imagem retoque pele desapareçe deixando apenas a camada abaixo visivel, mas na verdade a camada não foi excluida esta apenas invisivel, agora selecione a cor branca e selecione a ferramenta brush escolha um pincel redondo suave ajuste o  tamamanho para 131 px ajuste a opacidade do pincel para 70%

agora vamos analizar o que fizemos agora, preste atenção!, inserimos uma mascara de camada depois pintamos a mascara com a cor preta, a cor preta serve para ocultar a mascara e a cor branca serve para mostra-la, então agora vamos pintar a pele retocada sobre o rosto dela 

com a cor o tamanho e o pincel ajustados vamos pintar a pele retocada por cima da pele original

(iniciando processo de retoque pintando a pele da garota, perceba como a imagem retocada vai se revelando)

pinte todo o rosto da moça também pinte o pescoço, cuidado para não pintar por cima do cabelo ou fora da pele!

após terminar sua imagem devera ficar assim:

tenha cuidado para não exagerar no contraste lembre-se que a pele ainda deve se pareçer o mais realista possivel

- terminamos a parte da pele agora vamos aos labios

copie a camada "Backgound", arraste a camada de copia que acabou de ser gerada e coloque-a por cima de todas as layers como abaixo:

agora vamos utilizar o curves novamente vamos acessa-lo em image/adjustments/curves configure o gráfico como abaixo:

agora vamos dar a tonalização aos labios, vamos simular um batom Rosa vá em image/adjustments/Hue e Saturation deixe a janela como abaixo:

agora vamos aplicar a mesma tecnica como no retoque da pele vamos pintar o batom por cima da boca original, faça as mesmas etapas como no exemplo anterior

1. Crie uma mascara de camada
2. Pinte com a cor preta em cima da mascara
3. Com um pincel branco suave pinte a imagem do batom por cima da original

na hora de pintar ajuste a opacidade para 49% para a cor não ficar muito forte, o resultado deve ficar como abaixo:

depois escureça um pouco as sombracelhas use as configurações abaixo

escureça as sombrancelhas usando curves ajuste o gráfico como abaixo:

depois faça o processo da mascara de camada como nos labios para pintar por cima da imagem anterior.

você também pode clarear mais os olhos usando a ferramenta Dodge tool 

vamos terminar a maquiagem criando uma simulação de pô cor de rosa e aplica-los nas bochechas

crie uma nova layer selecione um pincel suave com a cor #da87a5 ajuste o tamanho para 215px e aplique o pincel em cima da bochecha direita e esquerda agora mude o modo de mesclagem para Overlay e diminua a opacidade para 75%

eis o resultado:

e por ultimo vamos dar mais cor aos cabelos dela usando Curves, copie a camada "Background" coloque-a por cima de todas as outras ou seja em 1° deixe o gráfico como abaixo:

depois faça o processo da mascara de camada e reduza a opacidade do pincel para 67% antes de pintar.

você também pode ajustar outras partes usando estas mesmas tecnicas

o resultado final:

espero que tenham gostado qualquer duvida ou problema é só comentar ali embaixo ok! =)

para saber mais sobre novidades me siga pelo twitter:@arielsantos95

Efeito Buraco Negro

Envelhecimento de Pessoas

Vamos continuar então Sr. Classe. Nosso próximo passo é desenvolver algo útil com essas benditas classes. Vou tentar mostrar no exemplo a seguir, uma comparação entre Programação OO e o Método "Normal". Vamos para o desenvolvimento de um mini carrinho de compras, talvez uma Cesta.

 <?php
class Cesta {
  var $Desconto;
  var $Preco = array();
  var $Quantidade = array();

  function Cesta($desconto) {
    $this -> Desconto = $desconto;
    }

  function AdicionarItem($item, $preco, $quantidade) {
    if( isset($this -> Preco[$item]) ) {
      $this -> Quantidade[$item]  = $quantidade;
      } else {
        $this -> Preco[$item] = $preco;
        $this -> Quantidade[$item] = $quantidade;
        }
    }
}

$MinhaCesta = new Cesta(10);
?> 

Calma, não desista, Objetos não é complicado, sei que deve ter parecido, mas veja com calma o exemplo:

. Do inicio até a linha 5, é o que vinhamos fazendo até agora, nada de novo;
. A função Cesta() está pedindo por uma váriavel $desconto, e essa função tem o mesmo nome que nossa classe, coencidencia? Não, de mandeira alguma, veja que ao chamar nossa classe na penultima linha, passamos um valor pela classe "10". Ao criar uma nova classe, ela automaticamente executa uma função com o mesmo nome que a classe. Então ao mesmo tempo executamos essa função e declaramos a váriavel Desconto com o valor 10. Que no final de tudo, essa será a porcentagem de descontos que o usuário ganhará em cima das compras;
. Já a função AdicionarItem() tem mais explicações sobre ela mesmo do que OO. Primeiro verificamos se já existe o item na nossa matriz, se ele existir, somamos o valor ao que já existe, se não existir, definimos o Preco[$item] com o valor que foi passado e atribuimos a quantidade que foi passada.

Como isso iriamo funcionar? Para adicionar itens ao nosso carrinho, fariamos dessa forma (o script acima já está em nosso código):

 $MinhaCesta -> AdicionarItem(1, 15.75, 10); 

Somente executamos a função AdicionarItem passando os valores 1 para o código do item, 15.75 como o valor do item e 10 como a quantidade.

Vamos virar o angulo de nossa atenção e ver como isso seria pela maneira tradicional. Provavelmente você teria que utilizar um banco de dados, onde cada item que seria adicionado no banco teria um código do usuário e sempre que fosse necessário puxar os dados, teriamos que fazer consultas ao banco de dados.

Mas qual a vantagem de jogar dentro de uma váriavel e na próxima página perdeu tudo? Então utilizaremos uma váriavel que não seja perdida na próxima página, podemos declarar uma váriavel de sessão como nosso objeto:

 $_SESSION['MinhaCesta'] = new Cesta(10); 

Resolvido o problema? Então temos um script que ficaria fácil de fazer uma manutenção, e sem utilizar recursos do servidor para conexões e consultados ao banco de dados. Vamos ver agora algumas funções que poderiamos anexar nesse nosso código:

 <?php
class Cesta {
  var $Desconto;
  var $Preco = array();
  var $Quantidade = array();

  function Cesta($desconto) {
    $this -> Desconto = $desconto;
    }

  function AdicionarItem($item, $preco, $quantidade) {
    if( isset($this -> Preco[$item]) ) {
      $this -> Quantidade[$item]  = $quantidade;
      } else {
        $this -> Preco[$item] = $preco;
        $this -> Quantidade[$item] = $quantidade;
        }
    }

  function RemoverItem($item, $quantidade) {
    if ( isset( $this -> Quantidade[$item] ) ) {
      if ( $this -> Quantidade[$item] >= $quantidade ) {
        $this -> Quantidade[$item] -= $quantidade;
        } else {
          $this -> Quantidade[$item] = 0;
          }
        } else {
          return false;
          }
    }

}

session_start();

$_SESSION['MinhaCesta'] = new Cesta(10);
?> 

Implementamos uma função para remover alguns itens que desejarmos. Algo como, adicionamos 50 mas tenho dinheiro para comprar somente 30, então preciso remover 20. Nossa primeiro comparação da função é ver se o item já está em nossa cesta, se não estiver, essa função retorna FALSE. A segunda comparação é ver se existe o total a ser removido no carrinho. Não teria lógica remover 70 itens se só tenho 50, e ficar com -20, isso provavelmente iria acarretar em problemas na contagem final. Se ele não tiver o total a ser removido ele define a váriavel Quantidade como 0.

Já temos nossas mãos na cesta, podemos adicionar e remover itens que desejamos, agora nos resta somente contratar nosso caixa:

 <?php
class Cesta {
  var $Desconto;
  var $Preco = array();
  var $Quantidade = array();

  function Cesta($desconto) {
    $this -> Desconto = $desconto;
    }

  function AdicionarItem($item, $preco, $quantidade) {
    if( isset($this -> Preco[$item]) ) {
      $this -> Quantidade[$item]  = $quantidade;
      } else {
        $this -> Preco[$item] = $preco;
        $this -> Quantidade[$item] = $quantidade;
        }
    }

  function RemoverItem($item, $quantidade) {
    if ( isset( $this -> Quantidade[$item] ) ) {
      if ( $this -> Quantidade[$item] >= $quantidade ) {
        $this -> Quantidade[$item] -= $quantidade;
        } else {
          $this -> Quantidade[$item] = 0;
          }
        } else {
          return false;
          }
    }

  function TotalCompras() {
    $soma = 0;
    while ( list($cod, $valor) = each($this -> Quantidade) ) {
      $soma  = $this -> Quantidade[$cod] * $this -> Preco[$cod];
      }
    $soma -= $soma * ($this -> Desconto / 100);
    return $soma;
    }

}

session_start();

$_SESSION['MinhaCesta'] = new Cesta(10);
?> 

Alguma dúvida sobre essa função? Uma simples para terminar. Somente percorremos toda a Matriz e calculamos a Quantidade de cada item * seu Proço unitário, aplicamos a porcentagem de descontos que o usuário tem e retornamos a Soma Total.

E como funcionaria todo o nosso script?

 <?php
class Cesta {
  var $Desconto;
  var $Preco = array();
  var $Quantidade = array();

  function Cesta($desconto) {
    $this -> Desconto = $desconto;
    }

  function AdicionarItem($item, $preco, $quantidade) {
    if( isset($this -> Preco[$item]) ) {
      $this -> Quantidade[$item]  = $quantidade;
      } else {
        $this -> Preco[$item] = $preco;
        $this -> Quantidade[$item] = $quantidade;
        }
    }

  function RemoverItem($item, $quantidade) {
    if ( isset( $this -> Quantidade[$item] ) ) {
      if ( $this -> Quantidade[$item] >= $quantidade ) {
        $this -> Quantidade[$item] -= $quantidade;
        } else {
          $this -> Quantidade[$item] = 0;
          }
        } else {
          return false;
          }
    }

  function TotalCompras() {
    $soma = 0;
    while ( list($cod, $valor) = each($this -> Quantidade) ) {
      $soma  = $this -> Quantidade[$cod] * $this -> Preco[$cod];
      }
    $soma -= $soma * ($this -> Desconto / 100);
    return $soma;
    }

}

session_start();

$_SESSION['MinhaCesta'] = new Cesta(10);

$_SESSION['MinhaCesta'] -> AdicionarItem("AF 1520", 17.90, 15);
$_SESSION['MinhaCesta'] -> AdicionarItem("AE 1735", 21.00, 5);
$_SESSION['MinhaCesta'] -> TotalCompras();
?> 

Dessa forma, se conclui o exemplo de nossa Cesta de Compras. Agora vocês se perguntam:

- Pronto, fico bonito, mas só posso fazer isso com OOP?

Como comentei no inicio, tudo pode ser feito, qualquer script que você faria da maneira "convencional" poderia ser feito Orientado à Objeto. Para se ter uma idéia de alguns outros tipos que podem ser bastante úteis é nas Manutenções gerais de um site, upload de arquivos, murais de mensagens/recados, etc... Muitos scripts podem ser criados, dê asas a sua imaginação.

E para quem gosta de repassar seus scripts, o que ficaria mais fácil, passar esse trecho de um código:

 class Cesta {
  var $Desconto;
  var $Preco = array();
  var $Quantidade = array();

  function Cesta($desconto) {
    $this -> Desconto = $desconto;
    }

  function AdicionarItem($item, $preco, $quantidade) {
    if( isset($this -> Preco[$item]) ) {
      $this -> Quantidade[$item]  = $quantidade;
      } else {
        $this -> Preco[$item] = $preco;
        $this -> Quantidade[$item] = $quantidade;
        }
    }

  function RemoverItem($item, $quantidade) {
    if ( isset( $this -> Quantidade[$item] ) ) {
      if ( $this -> Quantidade[$item] >= $quantidade ) {
        $this -> Quantidade[$item] -= $quantidade;
        } else {
          $this -> Quantidade[$item] = 0;
          }
        } else {
          return false;
          }
    }

  function TotalCompras() {
    $soma = 0;
    while ( list($cod, $valor) = each($this -> Quantidade) ) {
      $soma  = $this -> Quantidade[$cod] * $this -> Preco[$cod];
      }
    $soma -= $soma * ($this -> Desconto / 100);
    return $soma;
    }

} 

Ou uns 10-15 arquivos?

Conclusão

Sei que passei rápido demais o assunto sobre OO, mas acredite, não há muito o que se explicar. Isso é um método de programação, não uma função ou algo assim, que possa ter detalhes, exemplos ou mais coisas. Confesso que da forma que passei isso, restringue a pessoas que tenham já algum conhecimento em PHP, mas realmente, você primeiro precisa aprender PHP, para depois passar para OO, como espera criar funções e tudo mais se está apenas começando? Tudo ao seu tempo.

A intenção desse tutorial não é mudar o jeito de todos programar, pessoalmente, devo ter nem 30% dos meus trabalhos feitos OO. Como iniciei o tutorial, não há uma vantagem de um método sobre o outro, em alguns casos OO pode ser melhor e em outros a maneira convencional pode ser a melhor forma.

Com certeza, muitas dúvidas ficaram, expliquei um método de programação em 10 segundos... Espero somente desse tutorial é que, quem se interessar por OO, realmente tente desenvolver alguns mini projetos, e a qualquer dúvida, há várias pessoas aqui para lhe ajudar.

Mas acredite em uma coisa, saber quando, onde e porque utilizar OO é muito mais díficil que aprender a programar em OO.

Então, como diria alguém que mata 2 leões por dia com as unhas e dentes...

"Let the carnage begin" - Stormbringer.

Nem eu, nem qualquer outra pessoa no mundo pode chegar pra você e falar:

- Programe OO que é muito melhor.

Ou vice-versa. Não teve, não tem e provavelmente não terá nenhuma vantagem em relação a outra forma de programação. Tudo é uma questão de gosto e prática. Claro que, algumas vantagens uma tem em relação a outra, muitas pessoas comentam que programando OO você poderá publicar e buscar classes já prontas para fazer alguma função. Mas o mesmo aconteceria com a Programação "Normal". Comparar OO ao Método normal, é semelhante a comparar as funções echo ou print.

Portanto, não vou estar aconselhando a usar ou não usar OO, é simplesmente o seu gosto. Mas, como li em uma frase no livro PHP 4 - A bíblia.

"Não fique constrangido, caso um Programador OO diga que o script dele de 10 linhas é melhor que o seu de 5 linhas"

Realmente, programando em OO você terá um código fonte maior. Mas por outro lado, melhor compreendido (para outros programadores de OO) do que um código ao modo "normal".

O suporte a OO no PHP, como está no site oficial (php.net) é para usuários com experiências em outras linguaguens que são OO, como C#, e estão acostumados com ela. Por isso da introdução OO no PHP.

Vamos dar os parabéns para quem continuar, pois, está ciente que é uma maneira um pouco mais demorada, mas talvez possa ser mais organizada de programar. Não dúvido que muitos programadores ao lerem o texto acima, tenham para por ai. Nada de incomum, muitos irão ver OO e começar a programar nela, os demais, não veram vantagem nenhuma e deixarão de lado.

Introdução

Enfim, começaremos. Para qualquer programação OO, você criará tudo baseado em Classes, e as variáveis que você costumava usar, passarão a ser Objetos. Vamos à um exemplo:

 <?php
class MinhaClasse { // Declaração da Classe
    var $txt1; // Declaração das Variáveis
    var $txt2;
}

$MeuObjeto = new MinhaClasse();
?> 

Um exemplo sem utilização, mas que poderá nos ajudar a entender como criar uma classe. Na linha 2 (class MinhaClasse {) é onde declaramos nossa Classe, cada vez que quiser criar um objeto a partir dela, criaremos chamando pelo nome definido "MinhaClasse". Podemos criar quantas classes diferentes quiser, mas não pode ser em bloco:

 <?php
class MinhaClasse {
?>
<?php
    var $txt1;
    var $txt2;
}
?> 

O exemplo acima não irá funcionar. Voltando ao exemplo correto, as linhas 3 e 4 é onde declaramos nossas variáveis. Exato, para se trabalhar com classes, precisamos declarar as variáveis antes de usá-las. Mas não precisamos definir seu tipo, a não ser que queiramos uma Matriz:

 <?php
class MinhaClasse {
    var $txt1 = array();
    var $txt2;
}

$MeuObjeto = new MinhaClasse();
?> 

Acho que até aqui não teremos maiores problemas, vamos prosseguir.

Retornando valores das classes

Sei que a minha classe tem as váriaveis $txt1 e $txt2, mas como gravo e imprimo o que tem nelas? De uma maneira simples, mas não aconselhada, seria utilizar o operador "->". Vamos supor que o script acima faça parte do nosso código:

 echo $MeuObjeto -> txt1; 

Não, não esqueci do sinal $ antes de váriavel $txt1. Ao utilizar um objeto referenciamos as váriaveis dele somente com 1 sinal de $. Essa mesma forma poderia ser utilizada para definir valores à variavel:

 $MeuObjeto -> txt1 = "Olá Brasil!"; 

Mas então, porque comentei antes que não era aconselhado utilizar dessa forma? Pelo simples fato de estarmos trabalhando com classes não somente para ter uma espécie de Matriz Multidimensional, mas sim para organizar nosso código. E uma maneira organizada de se fazer isso seria trabalhar com funções dentro das classes:

 <?php
class MinhaClasse {
    var $txt1;
    var $txt2;

    function Retornar1() {
        echo $this -> txt1;
    }
}

$MeuObjeto = new MinhaClasse();
?> 

Agora você se pergunta "O que diabos faz aquele $this ali?". $this é somente uma referência à classe em que se encontra a função. Poderiamos sem problemas colocar no nome da classe para retornar o valor da váriavel, mas iria atrapalhar caso estivessemos trabalhando com classes hierarquicas, ter uma classe pai e filho. Mas isso não é hora de comentar ainda, mais pra frente veremos.

Voltando ao nosso código, veja que, a função está dentro de nossa classe, então para executar ela seria dessa forma:

$MeuObjeto -> Retornar1();

Certo, mas já que não utilizo a forma "antiga" para ler a váriavel, como faço para armazenar um valor à ela?

O segredo está nas funções:

 <?php
class MinhaClasse {
    var $txt1;
    var $txt2;

    function Retornar1() {
        echo $this -> txt1;
    }

    function Gravar1($valor) {
        $this -> txt1 = $valor;
    }
}

$MeuObjeto = new MinhaClasse();
?> 

Então ao executar a função $MeuObjeto -> Gravar1(), temos que passar um valor que será o novo valor da váriavel $txt1. Quaisquer outros tipos de funções podem ser declaradas dentro da classe, mas tenha idéia que trabalhar com OO é justamente para ter no final, um código limpo e de fácil entendimento. Talvez alguém está se perguntando, porque venho colocando váriaveis com letras maiusculas. Isso é somente seu estilo de programação, vinha fazendo com _ a um bom tempo, mas mudei o jeito por vontade própria ao iniciar em OO, acho que dessa forma fica mais fácil identificar. Mas como disse, é somente o gosto, poderia sem problema algum criar a classe minha_classe e $meu_objeto. Só cuidado com a forma MinhaClasse, pois PHP faz distinção entre váriaveis maiusculas e minusculas.

Acho que podemos encerrar nossa introdução por aqui. Na próxima parte vamos à alguns exemplos mais práticos.

No mundo de desenvolvimento de aplicações WEB principalmente com Java, temos problemas quanto ao desenvolvimento de interfaces, como incompatibilidade entre browsers, desenvolviemento lento, e outros detalhes que muitos vivenciam diariamente.
Existem soluções que prometem como o JavaServer Faces por exemplo, mas como dizem "A primeira experiência em Flex o programador Java nunca esquece." E eu também tive a mesma sensação e por isso decidi aprofundar-me e tentar passar minhas experiências e assim ajudar a outros que tiverem a mesmo sensação. Então, vamos conhecer a solução de desenvolvimento de interfaces Ricas, a Adobe Flex?.

Flex é um Framework "open source" altamente produtivo para construção de aplicações RIA (Rich Internet Application) podendo rodar em todos os principais browser bastando o uso do plugin Adobe Flash® Player e em desktop devido ao Adobe AIR?, o "cross-operating system runtime" que permite acessar dados localmente e recursos nativos do sistema operacional. Ambas alternativas são gratuítos.

O Flex fornece um moderno e padronizado modelo de programação composto por duas linguagens. O MXML, uma linguagem declarativa baseada em XML fascilita a geração da ferramenta RAD que inteligentemente está sendo desenvolvida como plugin para o Ambiente de Desenvolvimento Integrado Eclipse, o Flexbuilder Builder, o qual agiliza bastante a construção das Interfaces com o usuário. O comportamento, as funcionalidades, é programado em ActionScript? 3, agora uma poderosa linguagem de programação orientada a objetos. O Flex também fornece uma cada vez maior biblioteca de componentes e um interativo debugador.

Por que usar Flex

O Flex é executado a partir de uma máquina virtual, logo o programador apenas se preocupa em desenvolver a interface não em programar compatibilidade entre browsers e você ainda programa suas interfaces totalmente orientada a objetos, isso visa reuso de componentes, desenvolvimento de módulos e afins.

O estilo de programação e a diversidade do conteúdo que é possível criar com o flex, já que cada vez mais são disponibilizadas API's para interação com esta plataforma como o flicker, google maps, yahoo maps, youtube entre tantas outras. Sem falar da facilidade de uso das vantagens do Flash como animações frame-by-frame.

Requisitos de Instalação

1. Baixe a API do Flex e a descompacte em uma pasta a sua escolha, por exemplo: C:flexsdk.
Flex 3.2 SDK

2. Baixe o Ambiente de Desenvolvimento Eclipse e o descompacte em uma pasta a sua escolha, por exemplo: C:aplicativos.
Eclipse IDE for Java EE Developers
Ganymede Packages (based on Eclipse 3.4.1)

2.1 Baixe o Adobe® Flex® Builder 3 Professional Eclipse Plug-in. Como o próprio nome já diz, ele é um plugin para o eclipse, que adicionará todas as funcionalidades para o desenvolvimento de aplicações Adobe Flex 3 e Action Script 3.
Flex Builder 3

2.2 IMPORTANTE: O Flex Builder é trial com validade por 60 dias, porém a Adobe oferece aos estudantes o uso indefinido dessa ferramenta através do: "Adobe® Flex? Builder 3 Pro for Education".

2.3 Verifique as seguintes configurações no Eclipse:
a. em: windowpreferences...FlexInstalled Flex SDKs, adicone a sdk do passo 1. Por padrão ela instala a sdk que vem com o Flex Builder.

3. Baixe e execute o Adobe Flash Player 10 - Debugger Versions (aka debug players or content debuggers). Ele é a VM (virtual machine) onde será interpretada as instruções ActionScript.

Muito bem, feito tudo isso, temos o ambiente pronto para iniciarmos o desenvolvimento de aplicações Flex.

Por onde começar

Acredito fortemente que a teoria lhe fornece inicialmente base de conhecimento e pro fim aprimoramento, mas é a prática que o faz aprender; exemplos e repetições doutrinam o raciocíneo. É a prática que ensina o fazer! Portanto sou seguidor da PRÁXIS.
Outra característica de minha personalidade é dar o devido mérito e reconhecimento a quem de direito. Em meus estudo o que vejo de blogueiros fazendo plágio. Nem vou comentar!

Para iniciar os estudos em Flex, recomento o trabalho realizado pelo português, Mário Santos, do blog TWS. O Adobe Flex a partir do zero lhe dá uma noção inicial muito boa para lhe situar no mundo do desenvolvimento Flex. Paralelamente, isso mesmo paralelo - no mundo OO não existe como estudar sequencialmente. O Tutorial Action Script 3 lhe fornece a fonte de pesquisa e/ou estudo para o entendimento da ActionScript 3, a linguagem de programação sobre a qual é construído o Adobe Flex e a qual utilizamos para declarar o comportamento, funcinalidades, ou seja a parte dinâmica ou programática das aplicações Flex. Ambos Tutoriais estão em constante desenvolvimento e ainda possui vários outros materiais. Vale a pena acompanhar!

Depois disso, o próprio site da Adobe tem uma documentação vasta sobre Flex, tendo como ponto de partida: Quick Starts, Getting Started Experience e uma coleção de vídeos, Flex in a Week. Todos dentro da área voltada aos desenvolvimento, o devnet.

O site da comunidade Flex é também navegação obrigatório.

E finalizando temos um blogueiro que é referência, o pernanbucano, Igor Costa.

Gente, tomando como partidade estes materiais, sites, blog, somando a esporáticas consultas ao Oráculo, Google. É possível chegar a todo o conhecimento necessario para o desenvolvimento de aplicações RIA em Flex e suas integrações com PHP, Java e outras.

Um abraço a todos e bons estudos

A primeira maneira é usando o laço for..in. Esta técnica somente funciona para objetos dinâmicos, pois
ela enumera apenas as propriedades adicionadas dinamicamente. Ou seja, variáveis e métodos declarados não são enumerados em laços for..in. Veja exemplo:

<?xml version="1.0"?>
<!-- IntrospectionForIn.mxml -->
<mx:application creationcomplete="initApp()" xmlns:mx="http://www.adobe.com/2006/mxml">
<mx:script><![CDATA[
private var obj:Object = new Object();

private function initApp():void {
// propriedades adicionadas dinamicamente.
obj.a = "Schotten Totten";
obj.b = "Taj Majal";
obj.c = "Durche die Wuste";
}

public function dumpObj():void {
for (var p:String in obj) {
ta1.text = p ":" obj[p] "
";
}
}
]]></mx:script>
<mx:textarea height="200" id="ta1" width="400"/>
<mx:button click="dumpObj()" label="Dump Object"/>
</mx:application>

Exemplo retirado da documentação da adobe Flex.

A segunda maneira é usando a API de Instrospecção. Ela é apropriada quando se quer listar todas as propriedades e métodos públicos de uma classe não-dinâmica. Aqui destaco o método flash.utils.describeType(), o qual retorna um XML com a descrição da classe (E4X API). Veja exemplo:

<?xml version="1.0"?>
<!-- IntrospectionAPI.mxml -->
<mx:application creationcomplete="getDetails()" xmlns:mx="http://www.adobe.com/2006/mxml">
<mx:script><![CDATA[
import flash.utils.*;

public function getDetails():void {
// Fornece a descrição do Botão em E4X XML.
var classInfo:XML = describeType(button1);

// Lista o nome da classe.
ta1.text = "Class " classInfo.@name.toString() "
";

// Lista as variáveis do objeto, seus valores e seus respectivos tipos.
for each (var v:XML in classInfo..variable) {
ta1.text = "Variable " v.@name "=" button1[v.@name] " (" v.@type ")
";
}

// Lista os acessores como propriedades.
for each (var a:XML in classInfo..accessor) {
// Não fornece o valor da propriedade se for "write only".
if (a.@access == 'writeonly') {
ta1.text = "Property " a.@name " (" a.@type ")
";
}
else {
ta1.text = "Property " a.@name "=" button1[a.@name] " (" a.@type ")
";
}
}

// Lista os métodos do objeto.
for each (var m:XML in classInfo..method) {
ta1.text = "Method " m.@name "():" m.@returnType "
";
}
}
]]></mx:script>

<mx:button id="button1" label="This Button Does Nothing"/>
<mx:textarea height="200" id="ta1" width="400"/>
</mx:application>

Exemplo retirado da documentação da adobe Flex.

Saiba mais nas referências abaixo.

Referências

1. http://livedocs.adobe.com/flex/3/html/help.html?content=usingas_8.html
2. http://jsatriani.wordpress.com/2008/06/10/introspeccao-performance-java-x-action-script3/
3. http://www.as3dp.com/2007/05/05/runtime-checks-for-abstract-classes-and-methods-in-actionscript-30/ 

Por isso este ano decidi realmente aprender a orientação a objetos no PHP. Fruto desse aprendizado é este primeiro artigo sobre o tema e que tem por objetivo apenas apresentar de forma sucinta, clara, objetiva e de fácil compreensão pelos iniciantes do que é a orientação a objeto, seus principais conceitos e como fazer isso funcionar na prática.

Quando falamos em orientação a objetos (OO), em PHP, estamos falando basicamente de classes, métodos e propriedades.

Classe, no PHP, é um bloco de código escrito na forma abaixo:

 <?php
class NomeDaClasse {
   // Algum código aqui
}
?> 

Basicamente é o nome da classe, precedido da palavra reservada class e seguida de um par de colchetes {} o qual delimitará o código da classe.

Cada classe, no PHP, é um objeto, ou seja, uma coleção de métodos e propriedades.

Mas o que são métodos e propriedades?

Se você sabe o que é uma variável no PHP, sabe o que é propriedade, pois propriedades nada mais são do que as variáveis internas de uma classe, ou seja, são variáveis que você coloca dentro dos colchetes {} da classe.

Métodos são as funções internas das classes, ou seja, as funções que você coloca entre os colchetes {} da classe.

Abaixo um exemplo de classe, com métodos e variáveis.

 <?php
class NomeDaClasse {
   // As propriedades e ...
   $propriedade;
   $outra_propriedade = 'algum texto';

   // ... os métodos
   function meuMetodo(){
      // Algum código aqui
   }

   function outroMetodo($parametro){
      // Algum código aqui
   }
}
?> 

Muito bem, agora que sabemos estes três conceitos, vamos à prática, ou seja, vamos fazer uma classe, com seus métodos e variáveis, e ver como tudo funciona.

Criando uma classe
Agora é o momento de colocarmos em prática os conceitos de classe, métodos e propriedades. Para isso vamos construir uma classe de interação com o MySQL.

Essa classe deverá fazer algumas coisas:

• Conectar ao servidor MySQL e selecionar o banco de dados desejado;
• Configurar as variáveis (propriedades) dinamicamente;
• Executar consultas ao banco de dados, retornando o resultado;
• Retornar a string SQL usada na consulta.

Abaixo está o código completo da classe (mas não se preocupe, abaixo do código vamos explicá-lo passo a passo):

 <?php
/*
* Script para estudo sobre PHP e Orientação a Objetos
* @author Everton da Rosa (Everton3x)
* @copyright GPL
* @version 1.0 (21/04/2009)
*/

class TutoDB {
/*
   * Classe para interação com banco de dados
   * @author Everton da Rosa (Everton3x)
   * @version 1.0 (21/04/2009)
   */

   /*
   * Declaração das variáveis (propriedades) da classe
   */
   private $host; // Host (Servidor) que executa o banco de dados
   private $user; // Usuário que se conecta ao servidor de banco de dados
   private $pass; // Senha do usuário para conexão ao banco de dados
   private $db; // Nome do banco de dados a ser utilizado
   private $sql; // String da consulta SQL a ser executada

   function conectar(){
      /*
      * Função para conexão ao banco de dados
      * @author Everton da Rosa (Everton3x)
      * @return Object Retorna o objeto da conexão
      */
      $con = mysql_connect($this->host,$this->user,$this->pass)
      or die($this->erro(mysql_error()));
      return $con;
   }

   function selecionarDB(){
      /*
      * Função para seleção do banco de dados a ser usado
      * @author Everton da Rosa (Everton3x)
      * @return Boolean Retorna true (verdadeiro) ou false (falso)
      */

      $sel = mysql_select_db($this->db) or die($this->erro(mysql_error()));
      if($sel){
         return true;
      }else{
         return false;
      }
   }

   function query(){
      /*
      * Função para execução da consulta ao banco de dados
      * @author Everton da Rosa (Everton3x)
      * @return Object $qry Retorna o resultado da consulta como um objeto
      */
      $qry = mysql_query($this->sql) or die ($this->erro(mysql_error()));
      return $qry;
   }

   function set($prop,$value){
      /*
      * Função para atribuir valores às propriedades da classe
      * @author Everton da Rosa (Everton3x)
      * @param String $prop Nome da propriedade que terá seu valor atribuído
      * @param String, Array, Object Valor a ser atribuído
      * @return void Não dá nenhum retorno
      */
      $this->$prop = $value;
   }

   function getSQL(){
      /*
      * Função para retornar a string SQL
      * @author Everton da Rosa (Everton3x)
      * @return String String SQL
      */
      return $this->sql;
   }

   function erro($erro){
      /*
      * Função para exibir os error
      * @author Everton da Rosa (Everton3x)
      * @param String $erro Erro a ser exibido
      * @return void Não dá nenhum retorno
      */

      echo $erro;
   }
}

?> 

Inicialmente, indicamos a classe com a palavra-chave class e damos um nome a ela (TutoDB).

 class TutoDB { 

Em seguida, definiremos as propriedades da classe, que nada mais são do que variáveis que podem ou não receber valores desde já. No nosso casso, apenas definiremos as variáveis. Caso quiséssemos atribuir-lhes valor, faríamos $host = 'localhost'; por exemplo.

 /*
   * Declaração das variáveis (propriedades) da classe
   */
   $host; // Host (Servidor) que executa o banco de dados
   $user; // Usuário que se conecta ao servidor de banco de dados
   $pass; // Senha do usuário para conexão ao banco de dados
   $db; // Nome do banco de dados a ser utilizado
   $sql; // String da consulta SQL a ser executada 

Aqueles que já trabalham com classes sentirão falta das palavras public, private ou protected. Como disse inicialmente, este é um artigo básico. A questão sobre visibilidade fica para um próximo.

As propriedades que foram definidas servem para armazenar o host MySQL, o usuário, a senha e o banco de dados, além da string de consulta SQL ($host, $user, $pass, $db e $sql, respectivamente).

Depois disso, iniciaremos com os códigos do nossos métodos.

Temos seis métodos na nossa classe:

• conectar() serve para estabelecer uma conexão ao servidor MySQL (o host);
• selecionarDB() serve para selecionar o banco de dados desejado;
• query() executa a consulta ao banco de dados;
• set() é o método que atribui os valores ás nossas propriedades;
• getSQL() retorna a String SQL atribuída à propriedade $sql;
• erro() exibe mensagens de erro;

É importante salientar que não serão explicados o que cada método faz, pois isso fugiria do escopo do artigo. O importante é que se entenda que propriedades são objetos que são armazenados dentro da classe e que são utilizados geralmente pelos métodos e que métodos são partes da classe que fazem alguma coisa, geralmente baseados nas propriedades.

Na próxima parte do artigo veremos como utilizar esta classe e aprenderemos mais sobre a interação entre propriedades e métodos.

Utilizando a classe
Agora que temos a nossa classe pronta, vamos ver o que ela faz e entender um pouco mais sobre métodos e propriedades e a interação entre eles.

Primeiramente devemos instanciar a classe, ou seja, criar um objeto na memória que irá representar a classe TutoDB.

Isso nós conseguimos da seguinte maneira:

 $obj = new TutoDB; 

Com isso estamos dizendo ao PHP para armazenar na variável $obj uma nova instância da classe TutoDB.

Depois vamos atribuir valores às nossas propriedades da seguinte forma:

 $obj->set('db','information_schema');
$obj->set('host','localhost');
$obj->set('user','root');
$obj->set('pass','');
$obj->set('sql','select * from COLLATIONS'); 

Com isso dizemos ao PHP para utilizar o método set() do objeto armazenado em $obj (a classe TutoDB) para atribuir à propriedade passada pelo primeiro argumento o valor do segundo argumento.

Argumentos são os valores passados entre os parênteses das funções ou métodos. No caso da primeira linha, estamos dizendo para que seja colocado o valor information_schema na propriedade $db.

Poderíamos fazer isso de outra forma, sem utilizar um método, mas atribuindo diretamente um valor para a propriedade assim:

 $obj->db = 'information_schema' 

Por que então utilizamos um método para fazer isso?

Vamos supor que quiséssemos que a propriedade $user armazene apenas os valores 'root' ou 'admin'. Se deixássemos para atribuir valores em $user da forma $obj->user, qualquer valor poderia ser atribuído, mas se utilizamos um método para isso (no nosso caso, set()), podemos, dentro do método, colocar um código que verifique se o valor passado para ser armazenado na propriedade $user seja apenas root ou admin.

Vamos aproveitar e ver o método set():

    function set($prop,$value){
      /*
      * Função para atribuir valores às propriedades da classe
      * @author Everton da Rosa (Everton3x)
      * @param String $prop Nome da propriedade que terá seu valor atribuído
      * @param String, Array, Object Valor a ser atribuído
      * @return void Não dá nenhum retorno
      */
      $this->$prop = $value;
   } 

Veja que a atribuição de valor à propriedade é feita no seguinte esquema:

 $this->$prop = $value; 

Onde:
$this referencia a própria classe.

Precisamos fazer referência à classe pois se colocássemos apenas $prop = $value, estaríamos dizendo ao PHP para atribuir $value a uma variável chamada $prop, que poderia estar até mesmo fora da nossa classe.

Note também que o que o método faz é apenas $this->nomedapropriedade = valor a ser atribuído.

Seguindo?

Vamos conectar com o servidor MySQL com o método conectar() da seguinte forma:

 $obj->conectar(); // Realiza a conexão

   function conectar(){
      /*
      * Função para conexão ao banco de dados
      * @author Everton da Rosa (Everton3x)
      * @return Object Retorna o objeto da conexão
      */
      $con = mysql_connect($this->host,$this->user,$this->pass)
      or die($this->erro(mysql_error()));
      return $con;
   } 

Vejam que o método pega os valores das propriedades $host, $user e $pass para conectar ao servidor MySQL (mysql_connect($this->host,$this->user,$this->pass)), ou se der erro, para o script e chama o método erro() passando-lhe o parâmetro mysql_error() ( or die($this->erro(mysql_error()))).

Depois disso selecionamos o banco de dados desejado (que foi informado na propriedade $db):

 $obj->selecionarDB(); // Seleciona o banco de dados 

Em seguida realizamos a consulta ao banco de dados:

 $rs = $obj->query(); 

Todos os três métodos seguem um mesmo padrão: usam os valores armazenados nas propriedades para realizar alguma coisa.

Ainda falta pegarmos a string SQL com o seguinte código:

 $sql = $obj->getSQL(); // Pega o valor da propriedade $sql 

Observe que o método getSQL() apenas retorna o valor armazenado na propriedade $sql. Poderíamos fazer isso também da seguinte forma:

 $obj->sql; 

Por fim, vamos escrever algo para mostrar que nossa classe funciona:

 echo 'O número de linhas encontrado para a consulta '.$sql.' é de '.mysql_num_rows($rs); // Exibe o número de linhas do resultado

Se tudo funcionar, no navegador deve aparecer uma mensagem do tipo: O número de linhas encontrado para a consulta select * from COLLATIONS é de 127.

Agora temos o código completo para usarmos nossa classe:

 /*
* Testando a classe
*/

$obj = new TutoDB; // Instanciando a classe

// Atribuindo valores às propriedades da classe
$obj->set('db','information_schema');
$obj->set('host','localhost');
$obj->set('user','root');
$obj->set('pass','');
$obj->set('sql','select * from COLLATIONS');

$obj->conectar(); // Realiza a conexão
$obj->selecionarDB(); // Seleciona o banco de dados
$rs = $obj->query();

$sql = $obj->getSQL(); // Pega o valor da propriedade $sql
echo 'O número de linhas encontrado para a consulta '.$sql.' é de '.mysql_num_rows($rs); // Exibe o número de linhas do resultado 

Agora que sabemos o básico cobre classes, propriedades e métodos, vamos na conclusão abordar os principais conceitos do artigo.

Resumo final
Para finalizar o artigo, faremos um apanhados dos principais conceitos nele abordados:

Classes são blocos de código, geralmente tratando de operações relacionadas (banco de dados, arquivos etc) e que devem ser instanciadas (colocadas na memória) para serem usadas. Isso se faz da seguinte forma:

 $variavel = new NomeDaClasse; 

Propriedades são variáveis internas da classe que servem para armazenar dados que serão utilizados por métodos.

Para atribuir diretamente dados às propriedades fazemos:

 $variavel->nome_da_propriedade = dados a serem atribuídos; 

Para "ver" o que está armazenado na propriedade, fazemos o seguinte:

 $variavel->nome_da_propriedade; 

Métodos são funções internas das classes que realizam alguma coisa, geralmente tomando por base os dados armazenados nas propriedades.

Para executar um método, fazemos o seguinte:

 $variavel->metodo(); 

Dentro dos métodos, as propriedades e outros métodos internos da classe são referenciados utilizando $this:

 $this->nome_da_propriedade;
$this->nomeDoMetodo(); 

Espero que o leitor, principalmente o iniciante, tenha aprendido um pouco mais sobre classes, item básico para a compreensão do que é programação orientada a objetos no PHP.

Curso de PHP para iniciantes - Aula 5

Curso de PHP para iniciantes - Aula 4

Curso de PHP para iniciantes - Aula 3

Curso de PHP para iniciantes - Aula 2

Curso de PHP para iniciantes - Aula 1

O PHP é gratuito?
Sim! Para começar o PHP é open source, ou seja, código fonte aberto. Assim para obter o PHP a única coisa que deve fazer é entrar no site do PHP e fazer o download da versão mais nova. Pois com a versão mais recente terá novas funcionalidades além de possíveis bugs terem sido corrigidos.

PHP e o HTML
Uma pagina em PHP normalmente possui a extensão .php (dependendo da configuração do servidor Web). No entanto nestas páginas com a extensão .php pode ser inserido normalmente o código HTML que você já esta acostumado a desenvolver. E funcionara da seguinte maneira, sempre que o servidor receber páginas com a extensão .php ele saberá que a linguagem de programação na página, interpretando HTML, e ao encontrar código PHP interpretar os mesmos, ou vice versa e mais de uma vez pois não importa a quantidade de vezes que você altera entre código HTML e PHP e se você inicia o código com um ou com outro. Resumindo podemos escrever HTML e PHP em um arquivo .php que tudo será interpretado corretamente.

O PHP, o Server-side e o Client-side
Client-side
É tudo processado no lado do cliente. O client-side é interpretado diretamente pelo browser (navegador) do usuário. Sendo assim ao acessar uma página web o HTML, CSS e JavaScript são interpretados todos pelo navegador sem intervenção nenhuma de um servidor. Por isso podemos exibir o código fonte em nosso browser e visualizar o HTML, CSS e o JavaScript.

Server-side
O oposto do client-side. Aqui as informações são processadas por um servidor web que interpretara e retornará o resultado que será exibido no browser. Sendo assim não é possível visualizar o código de uma aplicação rodando no Server-side.

E o PHP?
O PHP é processado no servidor por isso é uma linguagem Server-side. Sendo assim suas aplicações não poderão ser copiadas por outras pessoas. Todos os processos, rotinas e funções serão feitas no servidor e o usuário recebera apenas o resultado em seu browser.

O que podemos fazer com o PHP
Interação com usuário
Primeiramente transformação de sites estáticos, que não possuem nenhum tipo de interação, em sites dinâmicos, com maior possibilidade de interação e dinamismo. Por exemplo, com páginas estáticas não podemos ter uma sessão de comentários em nosso site, em que ao terminar de ler um artigo a pessoa preencha um campo no formulário e deixar sua opinião e no mesmo estante a sua opinião estar no site, coisas que podemos realizar com o PHP e um banco de dados.

Facilidade na manutenção
Imagine um site que tenha 10 itens no menu do site e cada item abre mais 5 páginas internas, temos um total de 50 páginas. Agora imagine a situação: Seu cliente liga para você e pede para inserir mais um item no menu, lembrando que o menu esta presente em todas as páginas, o que você faria? Provavelmente abriria as 50 páginas e iria copiando e colando o código do menu entre elas, trabalho braçal bem chato né?, Além de possíveis erros. Mais continuemos você inseriu o item no menu, deve ter pensado que o problema acabou, mais não, no entanto no dia seguinte o item no menu que seu cliente havia chamado de contato na realidade ele lhe enviou o nome errado pois o pessoal do marketing descobriu que o nome fale conosco tem maior apelo com os clientes. E lá vai você novamente para o mesmo trabalho braçal.

E se fosse noticias que devem ser inseridas 3 vezes ao dia? Seu cliente mandaria a você, você as incluiria e sempre que houvesse erros você teria que ir lá e corrigi-las. Além de ter uma chamada com todas as noticias que você deveria atualizar também e uma chamada com foto na página inicial. Processo chato para você e o cliente.

Com o PHP podemos separar no primeiro caso o menu em um arquivo que ao ser atualizado seria atualizado em todo o site, pois este menu seria inserido em todas as páginas pelo PHP.
E no segundo caso das noticias poderíamos criar uma área administrativa em que apenas usuários logados, os administradores, teriam acesso e poderiam inserir e editar as noticias sem precisar entrar em contato com você.

PHP e o banco de dados
O PHP possui acesso a diversos bancos de dados. Sendo assim você terá uma serie de funções para poder utilizar entre os diversos tipos de bancos de dados suportados pelo PHP. Em nosso aprendizado utilizaremos o MySQL.

Exemplo de aplicações que podemos desenvolver com o PHP
Com o PHP podemos desenvolver coisas como áreas restritas que necessitem de autenticação, sistemas de comentários para artigos, noticias etc. Envio de emails, sistemas de noticias, lojas virtuais, redes sociais e qualquer outra coisa que você possa imaginar.
Uma aplicação web de grande porte que foi desenvolvida em PHP, foi a Wikipédia. Nela você encontra várias coisas como o sistema de autenticação, publicação e edição de artigos, upload de fotos entre outros.

Por que o PHP?
Utilizado amplamente no mercado em grandes empresas como na gigante Yahoo!, passando pela rede social Facebook, a enciclopédia livre e gratuita Wikipedia podemos citar também o flickr, SourceForge, Digg entre outras. E para quem é iniciante o PHP possui uma baixa curva de aprendizado com um material amplo, inclusive em português, e uma sintaxe bastante simples além de ser uma linguagem bastante robusta e flexível. Sem contar um fator essencial a grande comunidade de desenvolvedores PHP.

Classe para Carregar XML

O desenvolvimento de aplicativos com a Flash Platform para o Android só é possivel a partir do Android 2.2(Froyo) e usando Adobe AIR 2.5 e Flash Player 10.1

AIR for Android

Ferramentas de desenvolvimento
Adobe Flash CS5 Professional - É possivel desenvolver aplicativos para Android usando o Adobe Flash CS5 Professional, na ultima versão foi adicionado um profile "AIR for Android", gerando o arquivo ja com o tamanho padrão de 480×800. Por enquanto não existem componentes pré-programados para Android e não é recomendado usar os já existentes no Flash.

Adobe Flash Builder 4 (burrito) - A Adobe disponilibizou juntamente com o Flash Builder 4 (burrito), o SDK do Flex versão 4.5, com componentes otimizados para dispositivos moveis, para quem se recordar, a Adobe tinha um projeto de uma versão do Flex para mobile chamado "Slider", em virtude do rápido crescimento do processamento do smartphones atuais, a Adobe decidiu juntar esse projeto ao SDK padrao do Flex.

Qualquer editor de texto - Você pode usar qualquer editor de texto salvando na extensão .as ou seu editor ActionScript favorito.

Runtime Adobe AIR
Para que seu aplicativo rode em um dispotivo com Android, é necessario que seja instalado o runtime do Adobe AIR para logo em seguida você instalar seu aplicativo.

Distribuição
Você pode gerar o instalador do seu aplicativo pelo Flash Builder, Flash CS5 ou por linha de comando usando o ADT. É gerado um aplicativo com a extensão .apk. A distribuição pode ser feita atraves da Android Market, para se tornar um publisher da Android Market, basta pagar a inscrição de 25 dolares.
Acompanhe esse tutorial sobre como publicar seu aplicativo na Android Market
Caso você crie algo para rodar no Flash Player, basta rodar pelo navegador do smartphone, a Adobe tem uma página para que você possa ver alguns sites que usam Flash Player e que foram otimizados para mobile. Acesse o Adobe Flash Showcase for Mobile

Acompanhe alguns tutoriais:
Exemplos no Adobe Labs
Advanced Android development
Creating mobile apps for Android using Flash Builder "Burrito" and Flex SDK Hero
Test Drive for Mobile: Style the application

Nos proximos artigos, mostrarei como usar alguns recursos do AIR for Android

import flash.events.TransformGestureEvent;
import flash.display.Sprite;
import flash.events.MouseEvent;

//configurações do stage
stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
stage.scaleMode = StageScaleMode.NO_SCALE;
stage.align = StageAlign.TOP_LEFT;

//adicionando eventos de gestos para o stage, Zoom e Rotação
stage.addEventListener(TransformGestureEvent.GESTURE_ZOOM, onStageZoom);
stage.addEventListener(TransformGestureEvent.GESTURE_ROTATE, onStageRotate);

var Con:Sprite = new Sprite();
Con.x = stage.stageWidth * 0.5;
Con.y = stage.stageHeight * 0.5;
addChild(Con);

//criando os "Box's" e seus eventos
for(var i:uint = 0; i < 10; i++){
	var b:Sprite = Sprite(new box());
	//criando os Box's em todo stage
	b.x = Math.random() * stage.stageWidth - (stage.stageWidth * 0.5);
	b.y = Math.random() * stage.stageHeight - (stage.stageHeight * 0.5);
	b.rotation = Math.random() * 360;
	//eventos para arrastar
	b.addEventListener(MouseEvent.MOUSE_DOWN, onDown);
	b.addEventListener(MouseEvent.MOUSE_UP, onUp);
	//eventos para gestos de Zoom
	b.addEventListener(TransformGestureEvent.GESTURE_ZOOM, onZoom);
	//evento de gestos de Rotação
	b.addEventListener(TransformGestureEvent.GESTURE_ROTATE, onRotate);
	Con.addChild(b);
}

//função para quando mover o objeto
function onDown(e:MouseEvent){
	var b:Sprite = Sprite(e.currentTarget);
	Con.addChild(b);
	b.startDrag();
}
//função para quando soltar o objeto
function onUp(e:MouseEvent){
	var b:Sprite = Sprite(e.currentTarget);
	b.stopDrag();
}
//função para o Zoom
function onZoom(e:TransformGestureEvent){
	e.stopImmediatePropagation();
	var b:Sprite = Sprite(e.currentTarget);
	b.scaleX *= e.scaleX;
	b.scaleY = b.scaleY;
}
//função para a Rotação
function onRotate(e:TransformGestureEvent){
	e.stopImmediatePropagation();
	var b:Sprite = Sprite(e.currentTarget);
	b.rotation += e.rotation;
}
//função para Zoom do stage
function onStageZoom(e:TransformGestureEvent){
	Con.scaleX *= e.scaleX;
	Con.scaleY *= e.scaleY;
}
//função para a Rotação do stage
function onStageRotate(e:TransformGestureEvent){
	Con.rotation += e.rotation;
}