andré.santana [webdesign blog]

Archive for the ‘Action Script’ Category

O objetivo de classificar é agrupar elementos de acordo com seu grau de semelhança, seja qual for a classificação. Podemos enxergar isso de forma bem simplificada na classificação dos números:

N = { 1, 2, 3, 4, 5 … }

O conjunto dos números naturais é uma classificação numérica tal que seus elementos são todos maiores que zero (característica comum a todos os elementos). Se somarmos qualquer um de seus elementos, o resultado sempre será um elemento do mesmo conjunto, e muitas outras características dessa classificação, ou conjunto.

Analogamente, quando criamos classes, estas podem possuir características comuns e, portanto, podem ser agrupadas num conjunto de outras classes que também possuam estas características. Veja:

class bicicleta
{

function bicicleta(){} //construtor
/*
… corpo da classe
*/
}

class carro
{

function carro(){}
/*
… corpo
*/

}

Analisando as classes, percebemos que ambas caracterizam veículos de transporte. Logo, poderíamos agrupá-las em um conjunto que possua classes desse tipo (veículos de transporte). Formalmente, estes conjuntos são chamados Pacotes de classes. Sintaticamente (em forma de código), definimos o pacote em que a classe está pela forma: “class nome_do_pacote.nome_da_classe”. Veja:

class transporte.bicicleta
{

function celular(){} //construtor
/*
… corpo da classe
*/
}

class transporte.carro
{

function carro(){}
/*
…corpo
*/

}

É importante lembrar que, se as classes pertencem ao mesmo pacote, então elas devem estar na mesma pasta, que deve possuir o mesmo nome do pacote. De acordo com o exemplo, as classes estariam organizadas numa estrutura de arquivos da seguinte forma:
– ClassPath
– transporte
carro.as
bicicleta.as

Herança entre classes

Biologicamente, os organismos herdam características de seus antecessores, para que haja um reaproveitamento de características evolutivas, e não precise desenvolve-las repetidamente, ou seja, o código genético é reaproveitado.

Assim como reutilizamos os código genético de nossos antecessores, em programação orientada a objetos existem relações de herança entre classes. Quando uma classe herda as características (propriedades e métodos) de outra, dizemos que a classe herdada é superclasse da classe que herdou.

Um exemplo simples de onde ocorre essa herança de características são os carros, os quais todos têm funções como frear, acender o farol, buzinar, acelerar, e outras características comuns de um carro normal. Então, não faz sentido refazer estas funções para todos os carros que são produzidos. Cria-se uma função padrão que todos os carros herdem. Sintaticamente, a herança se dá da seguinte forma:

Class carro_base
{
function carro_base(){}
function frear(){}
function acelerar(){}
/* … */
}

Class ferrari extends carro_base
{
}

Diz-se, então, que a classe ferrari herdou a classe carro_base, ou seja, reaproveitou as funções básicas de um carro. Agora todos os métodos da classe carro_base também pertencem a classe ferrari.

Casualmente, algum método herdado pode ser insuficiente, pode ser necessário implementá-lo:

Class ferrari extends carro_base
{
function acelerar(){
super.acelerar()
/*
Processos adicionais
*/
}
}

Neste caso, a função de aceleração de um carro normal não foi suficiente para a ferrari, então nós utilzamos a função de aceleração padrão e incrementamos com outros processos.

Quando queremos fazer referência à superclasse, devemos utilizar o keyword super.

Espero que tenha ajudado um pouco!

Abraços!

por Caio Meriguetti

Anúncios

O ActionScript vem, desde a sua primeira versão, estabelecendo um papel importante na navegação em websites, sempre na interação usuário – website, tornando-a mais atrativa e fácil. O objetivo aqui é mostrar como é feito, e deixar as análises para os usabilidoidos da internet.

Quando navegamos, é difícil não perceber a presença de aplicações em flash, que hoje são desenvolvidas formalmente de acordo com conceitos de POO – Programação orientada a objetos, bastante organizada e hierarquizada, fazendo com que haja uma otimização dos códigos.

Saber, conceitualmente, ActionScript é fundamental para um bom programador, tanto quanto saber na prática. Alguns conceitos básicos e muito importantes:

Classe

Uma classe pode ser definida como uma coleção de funções, que chamaremos de métodos, e propriedades. Um exemplo bastante simples é o ser humano, que possui funções (andar, falar, gritar, correr, e outras milhares de funções biológicas) e também propriedades (cor dos olhos, altura, peso, cor dos cabelos e qualquer outra que se possa definir). Assim como classificamos os objetos, os animais, os números, buscando simplificar o nosso processo de aprendizado e execução de certas tarefas, o ActionScript nos possibilta criar classes (classificações). Veja:

// arquivo humano.as
class humano
{
var cor_olho : String = “Azul”;
var altura : Number;
var peso : Number;
var cor_cabelo : String;

function humano()
{
// construtor da classe, este método é chamado quando você cria uma instância da classe
}
function andar ()
{
}
function falar ()
{
return “Olá, eu sou uma instância da classe humano”;
}
function gritar ()
{
}
}

Para definir uma classe, usa-se:

class nome_da_classe_sem_espacos{
//corpo da classe
}

As classes devem ser armazenadas em arquivos separados de extensão “.as”, e para acessar métodos e propriedades da classe você deve criar instâncias.

var inst_humano:humano = new humano(); // o método humano() da classe é chamado
trace(inst_humano.cor_olho); // retorna “Azul” no painel output do flash.
trace(inst_humano.falar()); // retorna “Olá, eu sou uma instância da classe humano” no painel output do flash.

Membros da classe

Qualquer definição dentro de uma classe ou é um método ou é uma propriedade, que, generalizando, podem ser chamados de membros, os quais podem ter tipos diferentes. Podem ser públicos (public), privados (private) ou estáticos (static).

Tipos de membros

Um membro público sempre pode ser acessado pela instância da classe, em contrapartida, membros privados não podem.

//carro.as
class carro
{
public var placa:String = “MM 0056”;
private var volume_tanque:Number = 30;

public function acender_farol(){
return 1;
}

private function queimar_gasolina(){
return 1;
}
}

Quando instanciamos a classe no flash:

var inst_carro:carro = new carro();

trace(inst_carro.placa); // neste caso, você consegue acessar a propriedade

trace(inst_carro.volume_tanque); // neste caso não, ocorre erro dizendo que membros privados não podem ser acessados.

E análogamente:

trace(inst_carro.acender_farol()); // neste caso você consegue acessar o método

trace(inst_carro.queimar_gasolina()); // neste caso não, ocorre erro dizendo que membros privados não podem ser acessados.

Existem também membros estáticos, os quais não exigem uma instância para serem acessados.

class carro
{
public var placa:String = “MM 0056”;
private var volume_tanque:Number = 30;

public function acender_farol(){
return 1;
}

private var queimar_gasolina(){
return 1;
}
static function getNumeroRodas(){
return 4;
}
}

Para acessar o método getNumeroRodas basta, sem criar uma instância, digitar:

trace(carro.getNumeroRodas()); // retorna 4

Essa regra serve também para propriedades estáticas.

Bom, é isso pessoal, espero que tenha ajudado um pouco com conceitos do ActionScript.

por Caio Meriguetti 

Evento é um conceito extremamente útil e importante para o gerenciamento da interatividade em sistemas. Eventos acontecem a todo instante no momento da interação, quando o usuário clica em um botão, arrasta uma janela, move o mouse, dentre outras ações.

Analogamente à realidade, podemos citar o sistema nervoso humano que responde a cada interação com o nosso corpo com o ambiente. Neste caso, o sistema nervoso é que fica aguardando um evento ocorrer para, logo em seguida, avisar ao cérebro, e assim o cérebro poder responder.

Em programação orientada a objetos, o sistema de eventos é simples, existem objetos que disparam eventos (geradores de eventos) e outros que ficam na espera por eventos (escutadores de eventos). Um exemplo de objeto gerador de evento é um simples botão que ao ser clicado dispara um determinado evento.

No Actionscript, os eventos podem ocorrer de duas formas: um objeto dispara um evento para muitos outros (um para muitos) ou dispara um evento para um único outro objeto (um para um). A primeira forma é muito útil e importante quando temos que modificar vários objetos em função de uma ação específica, por exemplo, quando temos uma interface e queremos modificar vários elementos com apenas um clique, ou uma tecla apertada, a melhor forma de se fazer é utilizando um objeto que dispara o evento para muitos outros.

Na prática, o Flash possui uma classe nativa do pacote mx.events chamada EventDispatcher. Objetos que estendem esta classe são disparadores (ou dispachadores) de eventos, ou seja, são neles que os eventos ocorrem e em seguida são dispachados para um escutador.

// Classe disparadora de evento

import mx.events.EventDispatcher;
class disparador extends EventDispatcher {
function disparador() {
}
public function DisparaEvento() {
dispatchEvent({type:”evento”});
}
}

Depois de definida, quando você constrói um objeto desta classe, pode executar seus métodos normalmente, mas alguns métodos podem influênciar no sistema de forma abrangente, modificando objetos, alterando a interface, criando novos objetos ou qualquer outra consequência, neste caso definimos o método DisparaEvento que dispara o eveno chamado “evento”.

import disparador;
var disp:disparador = new disparador();
var listener1:Object = new Object();
var listener2:Object = new Object();
var listener3:Object = new Object();
listener1.evento = function() {
trace(“Listener 1”);
};
listener2.evento = function() {
trace(“Listener 2”);
};
listener3.evento = function() {
trace(“Listener 3”);
};
disp.addEventListener(“evento”, listener1);
disp.addEventListener(“evento”, listener2);
disp.addEventListener(“evento”, listener3);
disp.DisparaEvento();

Observe que, neste código, o objeto disp, ao executar o método DisparaEvento, influência outros 3 objetos (escutadores: listener1, listener2, listener3) de formas distintas. Um exemplo de caso em que podemos utilizar objetos escutadores é quando temos uma interface em várias línguas e quaremos modificar todos os elementos desta com apenas um clique (um disparador dispara um evento para vários listeners que modificam a interface).

Eventos de um para um são bem práticos e menos complexos. Quando temos um disparador que, ao disparar um determinado evento, implicam apenas uma conseqüência no sistema, utilizamos eventos de um para um. Veja:

class disparador2 {
public var onDispara:Function;
function disparador2() {
}
public function DisparaEvento() {
onDispara();
}
}

E para escutar o evento não é necessário criar objetos escutadores. Veja:

import disparador2;
var disp2:disparador2 = new disparador2();
disp2.onDispara = function() {
trace(“Disparou”);
};
disp2.DisparaEvento();

Download do arquivo de exemplo

por Caio Meriguetti 


Seja Bem-Vindo!

@andrehsantana

outubro 2017
S T Q Q S S D
« abr    
 1
2345678
9101112131415
16171819202122
23242526272829
3031  

RSS Feeds Deliciosos

  • Ocorreu um erro. É provável que o feed esteja indisponível. Tente mais tarde.

Blog Stats

  • 240,327 hits