um super hiper tuto com varios programas

[Hunter™ 1]

olá primeiro vou mostrar algumas coisa em xna c# então vamos começar

 

entendendo o funcionamento do xna : Olá! Hoje é o primeiro dia da série Guia do Iniciante! O tema é Entendendo o Funcionamento do XNA.

 

Nada melhor do que entender com o que você estará mechendo antes de programar algo, certo?

 

Neste tutorial você irá aprender como funciona o loop do XNA, e terá uma breve explicação sobre o mesmo.

 

Então vamos lá! A imagem abaixo resume o que o loop do XNA faz. Veja:

 

 

Observações sobre a imagem

 

-A primeira Coluna é executada apenas uma vez

 

-Os métodos Draw e Update são métodos que se repetem infinitamente até a aplicação fechar.

 

A estrutura acima seria o que um programador C++ deveria implementar por conta própria, por exemplo.

 

O bom do XNA é que ele implementa a parte “casca grossa” para nós e tudo de acordo com normas da Orientação à Objetos e com ajustes de performance.

 

Mas não pense que é tudo uma beleza de facilidade. Ele apenas simplifica e nos dá métodos e tipos de classe que facilitam.

 

Nada! Nem mesmo uma imagem é desenhada sem linhas de programação.

 

PS: Nada é visual, a não ser que você crie seu próprio editor de mapas ou de outras coisas.

 

Agora vamos explicar sobre a imagem:

 

As ações ou métodos citados abaixo são executados apenas uma vez

 

- Quando o programa inicia, as variaveis de topo de classe, ou seja, as declaradas logo após a criação da classe (fora de funções etc) são criadas e alocadas na memória.

 

- O método Main chama a classe Game. Sem esta chamada não vai acontecer nada!

 

- O Construtor (se não souber: é a primeira função à executar em uma classe, no construtor podemos pedir parametros e configurar as váriaveis de classe com tais parametros). Por padrão, o construtor da classe principal inicializa o GraphicsManager e o ContentManager, o primeiro é responsável pela configuração gráfica, já o segundo pelo gerenciamento do conteúdo (content), ou seja: Imagens, Modelos etc.

 

- Initialize(). Essa função, como mostra a imagem é executada logo após o construtor, por padrão ela vem vazia. Nela você pode configurar a altura da janela e outros parametros. Caso queira, também pode inicializar algumas classes.

 

- LoadContent serve para carregar o conteudo do seu jogo, ou inicializar alguma classe que necessite de um spriteBatch, já que o mesmo é inicializado neste método.

 

Os métodos citados abaixos serão repetidos até o fim da execução

 

- O método Draw obviamente é responsável por desenhar na tela, limpar a tela também é sua função. Passar parâmetros para o shader ou configurar o GraphicsDevice também pode ser executado nesta função.

 

- O método Update é executado após o Draw, então sempre é assim: Desenha. Atualiza. Desenha. Atualiza. […] Este método é responsável por atualizar a variavel gameTime, que fornece dados relativos ao tempo de execução, ou quantos segundos se passaram após a ultima chamada deste método. Nele podemos colocar códigos para verificar colisões, verificar o teclado, atualizar valores etc.

 

Os Shaders são chamados pelo método Draw

 

- A escolha da técnica pode ser feito fora ou dentro do método Draw. Dependendo da técnica escolhida uma função do arquivo que armazena o shader é executada.

 

- Vertex Shader. O vertex shader altera os vértices, isso inclui sua posição, coordenadas de texturização etc.

 

- Pixel Shader. O pixel shader nos oferece a possibilidade de adicionar luzes em uma cena 3D ou 2D. Trocar cores, realizar o efeito Blur (borrar a tela), mudar a cor de pixels etc.

 

Os shaders abrem possibilidades imensas para o programador, sendo que sem eles, nem mesmo um modelo 3D você consegue colocar na tela.

 

Após a execução dos shaders que ocorrem na placa de video (que deve suportar no minimo a versão 1.1 do PS e VS) o resultado é exibido na tela de seu computador ou televisão.

 

Então agora você já sabe alguma coisa sobre o XNA. Não é muito mas pelo menos você sabe como o XNA executa e em que ordem ele faz isto.

 

entendendo o codigo

 

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

 

oque o xna pode fazer e oque suporta : Antes de falar sobre o potencial do XNA vamos falar sobre quais formatos o XNA suporta e nada melhor do que a lista completa:

 

* Formatos 2D: DDS, BMP, JPG, PNG e TGA

* Formatos de Audio: XAP (projeto de audio gerado pelo XACT Tool), WAV, MP3 e WMA

* Formatos 3D: X (DirectX) e FBX (Formato da Autodesk mas já é suportado por alguns softwares free e pela maioria dos softwares de modelagem comercial)

* Fontes: SpriteFont (Arquivo XML usado pelo XNA onde você pode descrever as caracteristicas da fonte usada, como: tamanho etc.

* XML: Suporta arquivos .XML que podem ser usados para armazernar dados do jogo

* Shaders: Suporta arquivos .FX que são usados para descrever efeitos na renderização de modelos 3D ou 2D.

 

Lembrando que o XNA pode ler qualquer formato desde que o Content Pipeline seja extendido. Para carregar um modelo próprio deve-se conhecer a estrutura do mesmo.

 

Agora uma lista rápida com o que o XNA pode fazer:

 

* Criar jogos 2D

* Criar jogos 3D

* Aplicar Shaders

* Renderizar modelos animados

* Carregar e Ler arquivos

* Jogos Online

* E qualquer outra coisa, só depende da experiencia, habilidade e criatividade do programador

 

Tentarei manter esse tutorial como uma guia, então façamos um passo-a-passo.

 

Tenha seu projeto já criado e aberto.

 

1. Vá no Solution Explorer, na pasta Content * botão direito * : Add > Existing Item. Selecione a imagem desejada e clique em Add. Veja:

 

 

O XNA nos dá a classe Texture2D para armazenar uma imagem 2D. Então antes do contrutor (topo da classe) declare uma váriavel Texture2D:

 

Texture2D minhaTextura;

 

3. O próximo passo é carregar a textura; devemos fazer isso no método LoadContent(). Veja como deve ficar o seu método:

 

protected override void LoadContent()

{

// Create a new SpriteBatch, which can be used to draw textures.

spriteBatch = new SpriteBatch(GraphicsDevice);

 

minhaTextura = Content.Load<Texture2D>(”hellowordImage”);

 

// TODO: use this.Content to load your game content here

}

 

Lembre-se que somente o nome sem o .png ou formato deve ser colocado para carregar alguma midia.

 

4. Agora tudo o que falta é desenhar a textura. Isso deve ser feito no método Draw da sua classe, tudo o que precisamos fazer é:

 

protected override void Draw(GameTime gameTime)

{

GraphicsDevice.Clear(Color.CornflowerBlue);

 

spriteBatch.Begin(); // Inicie o spriteBatch

 

spriteBatch.Draw(minhaTextura, Vector2.Zero, Color.White); // Desenhe

 

spriteBatch.End(); // Finalize o spriteBatch

 

base.Draw(gameTime);

}

 

Vamos explicar:

 

Algumas linhas já são explicativas mas o método de desenho deve ser explicado. Ele possui 7 sobrecargas, mas usamos somente uma, veja o que ela pede:

 

spriteBatch.Draw(Texture2D umaTextura, Vector2 umVector2, Color UmaCor);

 

Usamos Vector.Zero, pois significa que a posição será 0,0 o que dá no canto superior esquerdo da tela. No próximo tutorial iremos falar sobre o Vector2.

 

Depois a Cor é geralmente Color.White pois a mesma não altera a imagem, se trocar por Color.Red a imagem virá avermelhada.

 

posicionando sua imagem :Vamos começar!

 

- “O que é um Vector2?”

 

Resposta: Vector2 nada mais é do que uma estrutura/classe que armazena duas coordenadas : X e Y

 

- “Mas se só serve para armazenar X e Y, por que não uso a classe Point?”

 

Resposta: As facilidades que Vector2 nos fornece são muitas. Temos funções como: Vector2.Lerp, Vector2.Subtract, Vector2.Mutiply que realizam calculos digamos que muito extensos e repetitivos.

 

Veja, por exemplo, como somar dois Points em um novo Point.

 

Point ponto1 = new Point(200, 200);

Point ponto2 = new Point(100, 100);

Point pontoResultante = new Point();

 

pontoResultante.X = ponto1.X + ponto2.X;

pontoResultante.Y = ponto1.Y + ponto2.Y;

 

O resultado é X = 300; Y = 300. Agora veja o mesmo exemplo com Vector2:

 

Vector2 vetor1 = new Vector2(200, 200);

Vector2 vetor2 = new Vector2(100, 100);

Vector2 resultado = new Vector2();

 

resultado = Vector2.Add(vetor1, vetor2);

 

Isto produz exatamente o mesmo resultado, obiviamente a diferença não foi grande, mas ao realizarmos, por exemplo, uma interpolação linear, a classe estatica Vector2 é de grande utilidade.

 

Agora vamos ver o problema de hoje.

O Problema

 

Precisamos mover a imagem de um lado para o outro na tela em um loop interminável.

 

Vamos analisar algumas palavras-chaves:

 

-Mover: Isso significa que precisaremos posiciona-la, ou seja, usaremos Vector2.

 

-De um lado para o Outro: Podemos usar velocidade para isso.

 

-Loop Interminavel: Isto rima com o método Update() =D

 

Vamos agora resolver o problema.

A Resolução

 

Antes de tudo, vamos resumir os passos. Lembre-se de criar um novo projeto.

 

-> NÃO EXIGE CÓDIGO

 

1. Salve a imagem abaixo:

 

 

2. Adicione a imagem ao projeto.

 

-> CÓDIGO NO TOPO DA CLASSE

 

3. Crie uma variavel Texture2D para armazenar a imagem

 

4. Crie uma variavel Vector2 para o posicionamento.

 

5. Crie uma variavel int para armazenar a velocidade.

 

-> CÓDIGO NO LOADCONTENT()

 

6. Carregue a imagem

 

7. Inicialize a posição

 

8. Defina a velocidade inicial

 

-> CÓDIGO NO UPDATE()

 

9. Defina o Loop principal

 

-> CÓDIGO NO DRAW()

 

10. Desenhe a imagem

 

Agora vamos ao Trabalho.

 

1. Você já salvou a imagem, certo?

 

 

3. Crie a váriavel Texture2D no topo da classe (antes do Construtor)

 

Texture2D t_Kakashi;

 

4. Agora criaremos a váriavel para posiciona-lo, adicione o seguinte logo abaixo de “Texture2D t_Kakashi;”

 

Vector2 p_Kakashi;

 

5. Adicione logo abaixo, a variavel que armazenará a velocidade.

 

int v_Kakashi;

 

6. Já no método LoadContent() carregue a imagem do Kakashi-san. Lembre-se que você pode colocar uma de sua preferencia, só basta carregar e substituir “Kakashi” por “NOME_DA_IMAGEM”.

 

t_Kakashi = Content.Load<Texture2D>(“Kakashi”);

 

7. Inicialize p_Kakashi, para fazer isso adicione logo abaixo:

 

p_Kakashi = new Vector2( 0 , 150);

 

8. Agora dê um valor para a velocidade da imagem

 

v_Kakashi = 2;

 

Isso significa que a velocidade dele será 2 pixels por atualização da tela.

 

9. No método Update() adicione a lógica. Veja como o mesmo irá ficar:

 

protected override void Update(GameTime gameTime)

{

if (v_Kakashi > 0) // Se a velocidade for maior que 0, ou seja positiva, significa que está indo para a direita

{

if (p_Kakashi.X < (Window.ClientBounds.Width – t_Kakashi.Width) – v_Kakashi)

{

p_Kakashi.X += v_Kakashi;

}

else

{

v_Kakashi *= -1;

}

}

else if (v_Kakashi < 0) // Se a velocidade for menor que 0, ou seja negativa, significa que está indo para a esquerda

{

if (p_Kakashi.X > 0)

{

p_Kakashi.X += v_Kakashi;

}

else

{

v_Kakashi *= -1;

}

}

 

base.Update(gameTime);

}

 

Vou explicar a lógica envolvida neste loop que faz a mágica para nós. Siga o raciocinio:

 

Se estiver indo para a direita, ou seja, a velocidade é positiva…

 

if (p_Kakashi.X < (Window.ClientBounds.Width – t_Kakashi.Width) – v_Kakashi)

{

p_Kakashi.X += v_Kakashi;

}

 

Se a posição X do Kakashi for menor que a largura da tela – a largura da imagem do Kakashi – a velocidade, ele avança 2 pixels no caso.

 

Nota: Lembre-se que no 2D começa-se a contar do canto esquerdo-superior, se você esqueçer de considerar a largura da imagem, a imagem vai sair da tela até o canto superior-esquerdo atingir o ponto desejado.

 

Então lembre-se que o espaço ocupado por uma imagem é igual à:

 

EspaçoTotal.X = Posicao.x + Imagem.Largura

 

EspaçoTotal.Y = Posicao.y + Imagem.Altura

 

Voltando…

 

else

{

v_Kakashi *= -1;

}

 

Agora se já estiver no limite da tela, a velocidade é invertida. Lembre-se que o sinal pode ser invertido multiplicando-se um valor por –1.

 

Agora a velocidade é –2, ou seja, é menor que 0, portanto está indo para a direita:

 

if (p_Kakashi.X > 0)

{

p_Kakashi.X += v_Kakashi;

}

 

Se sua posição X for maior que 0 ele irá “adicionar” a velocidade, mas no caso, a velocidade é –2, então na verdade irá subtrair 2 pixels da posição.

 

Agora se a posição é 0, então novamente se inverte a velocidade.

 

Terminada a lógica envolvida.

 

10. No método Draw() simplemente desenhe a imagem em sua respectiva posição. Por questões de estética, mude a cor de fundo para White (Branco). Veja como ficou seu método Draw:

 

protected override void Draw(GameTime gameTime)

{

GraphicsDevice.Clear(Color.White);

 

spriteBatch.Begin();

 

spriteBatch.Draw(t_Kakashi, p_Kakashi, Color.White);

 

spriteBatch.End();

 

base.Draw(gameTime);

}

 

Pressione F5 para realizar o Debug e veja o programa em ação!

 

 

vamos entrar em delphi

 

rie uma tela nova no sistema, altere as propriedades Name = FrmGrafico e Caption = Gráfico de Clientes por Cidade.

Insira um objeto Chart (Additional) à tela. Altere as propriedades Name = chtGrafico, Align = alClient e dê um duplo-clique sobre o mesmo.

Escolha o tipo de gráfico a ser utilizado: Bar (Barras). Para isto, clique nas guias Chart, Series e nos botões Add (Desmarque a opção 3D) e OK.

Clique no botão Titles e altere o título da série para Cidades.

Selecione a guia Titles e digite o título do gráfico: Clientes por Cidade, na caixa de texto e selecione o Alignment = Center .

Clique no botão Close. Faça referência à unit da tela DM. File -> Use Unit (UDM)

Insira um objeto ADOQuery à tela e altere as propriedades:

Name: QCliCid

Connection: Dm.Conexao

SQL: Select Count(*) as Qtde, CliCid From Clientes Group By CliCid

Dê duplo-clique na query QCliCid e tecle [Ctrl] + [F] para inserir os campos.

Copie o botão Btn_Imprimir da tela FrmCadCliente para a tela FrmGrafico. Insira um componente PrintDialog da guia Dialogs na tela FrmGráfico.

 

No Object Inspector, selecione o objeto Series1 do gráfico chtGrafico

Altere a propriedade Name para CliCid

No evento OnShow da tela FrmGrafico, digite os seguintes comandos:

 

Código:

 

CliCid.Clear;

chtGrafico.Title.Text.Clear;

chtGrafico.Title.Text.Add('Gráfico Clientes por Cidade’);

QCliCid.Open;

While (not QCliCid.Eof) do

begin

// Insere dados do Eixo Y do gráfico de barras

CliCid.AddY(QCliCidQtde.Value, QCliCidCliCid.AsString, clSkyBlue);

QCliCid.Next;

end;

 

Digite os comandos a seguir no evento OnClick do botão Imprimir:

 

Código:

 

if PrintDialog1.Execute then

begin

chtGrafico.BackColor := clWhite;

chtGrafico.Print;

end;

 

Acrescente um botão com Caption = Gráfico à tela FrmCadCliente e chame a tela FrmGráfico através dele.

 

bom só isso que eu aprendir a fazer em delphi

 

vamos entrar em java

 

Java é uma linguagem orientada a objetos e, com isso, não é possível desenvolver nenhum programa sem seguir tal paradigma. Um sistema orientado a objetos é composto por um conjunto de classes e objetos bem definidos que interagem entre si, de modo a gerar o resultado esperado.

5.1 O que é?

 

O avan´o das tecnologias na área de análise, projeto, desenvolvimento e qualidade de software permite que aplica´ões mais flexíveis e poderosas sejam construídas. A necessidade de integrar estas aplica´ões criou uma nova metodologia de análise e desenvolvimento: a Orienta´ão Ã* Objetos.

 

A Orienta´ão Ã* Objetos modela o mundo real com classes e instâncias. Cada classe é a estrutura de uma variável, ou seja, um tipo de dado. Nela, são declarados atributos e métodos que poderão ser executados ou acessados nas instâncias da mesma classe. As classes possuem uma fun´ão muito importante na modelagem orientada a objetos, elas dividem o problema, modularizam a aplica´ão e baixam o nível de acoplamento do software.

 

Variáveis de uma classe são chamadas de instâncias de classe. Por exemplo: Se existe uma classe Pessoa existe a instância (variável) pessoa que é do tipo Pessoa. Um Objeto, ou instância, é uma entidade cujas informa´ões podem incluir desde suas características até suas atividades, ou seja, uma abstra´ão de um domínio de um problema.

 

Abaixo há uma série de defini´ões sobre a arquitetura de orienta´ão a objetos em Java.

 

* Pacote: Conjunto de classes e demais arquivos que possuem interesses comuns ou atuam com dependências entre si. Fisicamente são pastas do sistema operacional.

* Instância, objeto: Uma variável do tipo de uma classe.

* Construtor: Responsável por iniciar a cria´ão e inicializa´ão de uma instância de classe.

* Método: Fun´ões referenciados aquela classe.

* Modificador de acesso: Descreve que outras classes podem ter acesso a classe que está se criando. Também é usado para indicar que uma classe pode ser acessada de fora de seu pacote.

* Hierarquia de classes: Um grupo de classes que estão relacionadas por heran´a.

* Superclasse: É a classe que é estendida por uma determinada classe.

* Subclasse: É a classe que estende determinada classe.

* Classe base: A classe de determinada hierarquia que é uma superclasse de todas as outras classes. A classe? pai de todas?

 

5.2 Criando a primeira classe

 

Nesta apostila já foram criadas várias classes demonstrando outras funcionalidades da linguagem. Nos exemplos anteriores todo o código que continha um public class declarava uma classe. Porém, os exemplos anteriores tinham propósitos de explicar cada tópico, e portanto não faziam muito sentido. Neste exemplo, será construído uma classe Pessoa, que manterá os dados e as a´ões relativas aos dados de pessoa.

 

public class Pessoa {

String nome;

Date nascimento;

double dinheiroNaCarteira;

 

public Pessoa(String nome, Date nasc) {

this.nome = nome;

this.nascimento = nasc;

}

 

public void gastar(double valor) {

dinheiroNaCarteira -= valor;

}

 

public void receber(double valor) {

dinheiroNaCarteira += valor;

}

}

 

A classe pública Pessoa acima possui três variáveis, também chamados de atributos de instância: nome, nascimento, dinheiroNaCarteira. Esses atributos serão criados a cada nova instância de Pessoa que existir no sistema. Há, também, dois métodos: gastar (double valor) e receber (double valor). Eles retiram e incluem dinheiro na carteira da Pessoa respectivamente.

 

 

 

Entre eles existe a defini´ão de um construtor: public Pessoa (String nome, Date nasc). O construtor é um método sem retorno, invocado quando ocorre a cria´ão de um Objeto. Esta classe pessoa só pode ser criada passando dois parâmetros: o nome e a data de nascimento. Se este método não existisse, o java criaria um construtor padrão, sem parâmetros, para que a classe possa ser instanciada.

 

Algumas classes precisam evitar ser instanciadas, para ter essa prote´ão cria-se um construtor privado que não recebe parâmetro e também não possui corpo. É construído para evitar que o Java crie o construtor default.

 

Não é necessário defini´ão de atributos, métodos ou construtores para que uma classe possa ser compilada. A declara´ão abaixo é válida, o javac compila corretamente e pode-se criá-la na aplica´ão, mesmo que sem nenhum método, construtor ou atributo:

 

public class NãoFazNada { }

 

O código abaixo usa a classe Pessoa como um exemplo de aplica´ão Orientada a Objetos.

 

public class GerenciadorDePessoas {

public static void main(String args[]) {

// Cria uma classe que formata datas.

// É capaz de formatar de String para uma

// Date e de um Date para um String.

SimpleDateFormat formatador =

new SimpleDateFormat("dd/MM/yyyy");

 

// Cria um Objeto de Pessoa.

Pessoa pVitor;

pVitor = new Pessoa("Vitor Fernando Pamplona",

formatador.parse("07/11/1983"));

 

// Vitor Recebeu 1000 reais

// Inclui R$ 1000 na carteira da

// pessoa p criada na linha anterior

pVitor.receber(1000.00);

 

// Cria um outro objeto de pessoa, o João

Pessoa pJoão = new Pessoa("João da Silva",

formatador.parse("18/02/1970"));

 

// João recebeu R$ 500 e gastou R$ 100

pJoão.receber(500.00);

pJoão.gastar(100.00);

}

}

 

Primeiramente é criado um formatador de datas para que se possa converter uma data formatada em String em um tipo Date do Java. Este formatador é uma instância da classe SimpleDateFormat e, como qualquer outra cria´ão de objeto, usa o comando new para criar uma instância.

 

Na linha seguinte, existe a declara´ão da variável pVitor que é da classe Pessoa. Esta variável ainda não está criada, portanto o valor que ali se encontra é null. Após, é criado a variável, ou melhor, a instância da classe Pessoa, com escopo do método. Esta instância já é inicializada com o nome Vitor Fernando Pamplona e a data de nascimento 07 / 11 / 1983. Na linha abaixo é invocado o método receber da classe Pessoa passando como parâmetro o double 1000.00.

5.3 Modificadores

 

Em Java existem uma série de palavras-chave que se comportam como modificadores de classes, métodos e atributos. Alguns desses modificadores já foram usados nesta apostila como a palavra-chave public, por exemplo. Um modificador pode ser utilizado antes da palavra class, antes do retorno de um método ou antes da declara´ão de um atributo.

 

Abaixo segue uma tabela com todos os modificadores de acesso do Java. A ordem de declara´ão dos modificadores não importa.

Palavra-chave Em uma classe Em um m étodo Em um atributo

 

public Acesso total Acesso total Acesso total.

 

private Não aplicável Acesso pela classe Acesso pela classe

 

protected Não aplicável Acesso pelo pacote Acesso pelo pacote

 

default Somente pacote Acesso pelo pacote Acesso pelo pacote

 

abstract Não instância Deve ser sobrescrito Não aplicável.

 

final Sem heran´a Não pode ser sobrescrito CONSTANTE..

 

static Não aplicável Acesso pela classe Acesso pela classe

 

native Não aplicável Indica código nativo Não aplicável

 

transient Não aplicável Não aplicável Cache

 

synchonized Não aplicável Sem acesso simultâneo. Não aplicável

 

5.4 Métodos

 

Um método em Java é uma sub-rotina semelhante as fun´ões de C e Pascal. Os métodos têm um retorno e podem conter parâmetros. A Sintaxe de um método é a seguinte:

 

[modif] <retorno> <nome> ([<tipo param>],[...]) {

<corpo do método>

}

 

Ao declarar um método é possível adicionar modificadores, vistos na se´ão anterior, antes de informar o tipo de retorno. O modificador estático declara que o método terá um determinado tipo de comportamento dentro do programa orientado a objetos. Na declara´ão de um método os modificadores precedem o tipo de retorno, que precede o nome do método e a lista de parâmetros. O corpo do método é colocado entre chaves.

 

Buscando o exemplo da classe pessoa:

 

 

 

//<modif> <ret> <nome> <parametro>

public void gastar(double valor) { // Corpo

dinheiroNaCarteira -= valor;

}

 

O corpo do método pode conter declara´ões de variáveis e comandos. As variáveis não ficam restritas a declara´ão somente antes dos comandos, como acontece em C ou em um local pré-determinado como em Pascal, ao contrário, podem ser declaradas em qualquer lugar. O tipo de retorno de um método pode ser primitivo ou de referência, ou como no método main, pode ser void, ou seja, não retorna nada.

 

Em Java todos os argumentos são passados por valor. Não existe passagem por referência. Se for variável primitiva o valor da variável é passada no parâmetro e pode ser alterada a vontade dentro da fun´ão que nada sofrerá a variável externa. Com objetos o que muda é que o valor passado no parâmetro da fun´ão é a referência para o objeto, ou seja, se um objeto for alterado dentro da fun´ão, o objeto externo também será alterado, exceto nas instru´ões objeto = null;

5.5 Interfaces

 

Interfaces foram concebidas para criar um modelo de implementa´ão aumentando o baixo acoplamento entre determinadas partes de um software. Uma interface não pode possuir atributos de instância e nem métodos com implementa´ão, mas pode possuir atributos de estáticos (de classe) e cabe´alhos de métodos que deverão ser desenvolvidos nas classes que implementarão a interface.

 

Muitas vezes as interfaces representam a´ões ou papéis para as classes. Um exemplo comum de interface é a Serializable que se encontra dentro do pacote java.io e é muito utilizada em aplica´ões corporativas. Quando uma classe implementa Serializable ela não precisa implementar nenhum método definido na interface, mas com esta a´ão o programador indica ao java que a classe pode ser serializada, transformada em um conjunto de bits para serem armazenados ou transmitidos. A serializa´ão de uma instância armazena todos os seus dados e consegue criar um objeto semelhante na desserializa´ão.

 

O uso de interfaces é semelhante ao de classes como mostrado abaixo.

 

public interface Impressao {

public void imprimir();

}

 

public class Pessoa implements Impressao {

private String nome;

...

public void imprimir() {

Impressora imp = new Impressora("LPT1");

imp.print("Pessoa: " + nome);

...

}

}

 

public class Documento implements Impressao {

private String número;

...

public void imprimir() {

Impressora imp = new Impressora("LPT1");

imp.print("Documento: " + número);

...

}

}

 

No exemplo acima é possível identificar uma interface Impressão que é implementada pela classe Pessoa e pela classe Documento. Essas duas classes foram obrigadas a implementar o método public void imprimir () definido na interface. Se isso não acontecesse o javac, o compilador do java, não permitiria a compila´ão das classes.

 

Para implementar uma interface, usa-se a palavra-chave implements seguida do nome da interface, ou interfaces, visto que não há limite para quantidade de classes em implementa´ão.

 

É correto afirmar que as classes ganharam um papel, uma a´ão de impressão, e estão aptas a executar todos os ítens necessários para realizar tal tarefa.

5.6 Abstract Class

 

Uma classe abstrata é quase uma interface, com a exce´ão que ela pode conter implementa´ões. Uma classe abstrata é usada para manter alguma programa´ão nas classes ? Pai ?, porém não pode ser instanciada. Para ser utilizada como instância, uma classe abstrata deve ser estendida por uma classe não abstrata.

 

public abstract class Veículo{

private String nome;

private String marca;

private String modelo;

 

// sets e gets

 

public abstract void andar();

}

 

public class Carro extends Veículo {

public void andar() {

acelerar();

}

 

private void acelerar() {

...

}

}

 

public class Bicicleta extends Veículo {

public void andar() {

pedalar();

}

 

private void pedalar() {

....

}

}

 

Como é possível observar no exemplo acima, a classe Veículo não pode ser instanciada por ser abstrata, e ela ganhou esta característica por conter métodos abstratos, no caso o método andar (). Por este motivo, foram criadas duas classes estendendo Veículo: Carro e Bicicleta. Ambas implementam a sua maneira de andar.

 

Para criar uma extensão de qualquer classe, usa-se a palavra-chave extends. O Java não permite a heran´a múltipla, como em C, portanto não é possível estender de duas ou mais classes. A solu´ão deste problema é trabalhar com interfaces.

5.7 this e super

 

Estas duas palavras-chave da linguagem são aplicadas a métodos não estáticos, ou seja, de instância. A this é utilizada para referenciar variáveis ou métodos da instância atual e o super é utilizada para associar a métodos da classe ? pai ?. Por exemplo:

 

public class Pai {

public int lan´ar(int numero) {

return 6 \% numero;

}

}

 

public class Filho extends Pai {

private int numero;

...

public int lan´ar(int numero) {

if (numero == 0) {

return this.numero; // retorna o atributo da classe

}

super.lan´ar(numero); // Chave o lan´ar da classe pai.

}

}

 

A classe Pai possui um método lan´ar retornando um inteiro. A classe filho, que estende de Pai foi criada para tratar uma divisão por zero que poderá ocorrer na classe Pai. Portanto, se for zero, retorna um número predefinido como atributo na classe Filho, caso contrário retorna o resultado do cálculo da classe Pai. Este é um excelente exemplo de polimorfismo e sobrescrita de métodos que veremos a seguir.

 

O Java associa automaticamente a todas as variáveis e métodos referenciados com a palavra this. Por isso, na maioria dos casos torna-se redundante o uso em todas as variáveis da palavra this. Existem casos em se faz necessário o uso da palavra this. Por exemplo, você pode necessitar chamar apenas uma parte do método passando uma instância do argumento do objeto. (Chamar um classe de forma localizada);

5.8 Sobrescrita e Sobrecarga

 

O Java permite que você tenha métodos com o mesmo nome, mas com assinaturas diferentes, isto chama-se sobrecarga. O interpretador determinará qual método deve ser invocado pelo tipo de parâmetro passado. Os trecho abaixo é válido para uma compila´ão Java.

 

...

public void print( int i ) { ... }

public void print( float f ) { ... }

public void print( String s) { ... }

...

 

Quando você escreve o código para chamar um desses métodos, a chamada deverá coincidir com tipos de dados da lista de parâmetros de algum dos métodos.

 

Diferente da sobrecarga, a sobrescrita acontece quando um método existe em uma classe ? pai ? e é reescrito na classe ? filha ? para alterar o comportamento. A assinatura do método deve ser igual na classe ? pai ? e na classe ? filha ?. Como um exemplo abaixo está o código desenvolvido na se´ão this e super.

 

public class Pai {

public int lan´ar(int numero) {

return 6 \% numero;

}

}

 

public class Filho extends Pai {

public int lan´ar(int numero) {

if (numero == 0) {

return this.numero; // retorna o atributo da classe

}

super.lan´ar(numero); // Chama o lan´ar da classe pai.

}

}

 

O método public int lan´ar (int numero) existe na classe filha e na pai, o primeiro a ser invocado é o Filho, e, via a palavra chave super, o interpretador chamará o método pai. Caso não houver o comando super.lan´ar (numero); o método pai não seria invocado.

5.9 Cast ou conversão de Objetos

 

O cast ou a conversão de objetos em java é realizada de duas maneiras, de acordo com a conversão de tipos primitivos: implícito e explícito. Primeiramente, toda a classe ? filha ? pode ser associada a uma declara´ão de class ou interface ? pai ?. Esta é a forma implícita, pois não necessita de nenhum recurso para ser efetuado, como no exemplo abaixo:

 

...

Pai objeto = new Filho();

...

 

No exemplo, o objeto filho é declarado como uma instância de Pai. O inverso deste caso ocorre quando tem-se um objeto ? pai ? e sabe-se que ele é uma instância de determinada classe ? filho ?. Esta forma é a explícita, pois é necessário informar ao compilador, qual a classe que deseja-se fazer o cast.

 

...

Pai objeto = new Filho();

...

Filho objFilho = (Filho)objeto;

...

 

No exemplo, o objeto é declarado como sendo instância de Pai, mas é criado uma instância de Filho. Na linha seguinte, é associado a uma variável declarada como Filho o valor de objeto, que foi declarado como Pai mas é possível saber que ele é um Filho.

5.9.1 Operador instanceof

 

O operador instanceof é utilizado para casts explícitos que não se tem conhecimento da classe real do objeto. Por exemplo:

 

...

public void write(Collection c) {

if (c instanceof List)

write((List) c);

else

write((Set) c);

}

...

 

No exemplo, a instância de Collection é testada para verificar se é um List ou um Set. De acordo com o valor dela, é chamada uma fun´ão write usando sobrecarga de métodos.

6 Tratamento de Exce´ões

 

As exce´ões em Java são classes que herdam de java.lang.Throwable. Basicamente existem três tipos de exce´ões que são herdadas de Throwable:

 

* Error: Exce´ão grave que normalmente não pode ser tratado, como falhas físicas e condi´ões anormais de funcionamento.

* Exception: Exce´ões genéricas que devem ser tratadas utilizando declara´ões throws ou criar o tratamento para a exce´ão com try catch.

* RuntimeException: São exce´ões que podem ser lan´adas durante a execu´ão da JVM. Podem ser tratadas, porém não precisam ser tratadas com throws ou com try catch

 

Em Java pode-se escolher onde se quer tratar a exce´ão. Se for para tratar no mesmo método que ela ocorreu, usa-se a instru´ão:

 

try {

<comandos>

} catch (<Exce´ão>) {

<comandos>

} catch (<Outra Exce´ão>) {

<comandos>

} finally {

<comandos>

}

 

A instru´ão try, como seu nome já fala, tenta executar um bloco de comandos. Ao ocorrer qualquer erro a JVM passará o controle para um dos catch, o que mais se apropriar para a exce´ão lan´ada.

 

Se a JVM não encontrar um catch apropriado e se houver uma cláusula finally ela é executada, se não houver um finally o Java repassa a exce´ão para o método que chamou este, e assim continua até que a exce´ão seja simplesmente lan´ada na tela para o usuário.

6.1 Instru´ão throws

 

As classes que herdam de Exception precisam ser mapeadas como possibilidade de erro no código Java. Quem controla essa obrigatoriedade é o compilador. Por exemplo, a classe java.sql.SQLException é utilizada para tratamento nas exce´ões de SQL quanto conecta-se a um banco de dados. Esta classe precisa ser obrigatoriamente testada, caso contrário o programa não compila.

 

Para tratá-la pode-se usar a instru´ão try no mesmo método, porém, as vezes, é necessário que essa execu´ão seja tratada no método que chamou este. Neste caso, coloca-se a instru´ão throws na assinatura do método afirmando para o compilador que os métodos que chamarem este devem tratar SQLException obrigatoriamente.

 

....

public void salvaObjeto( Cliente c) {

try {

abreTransa´ão();

incluiNoBanco©; // throws SQLException

commitTransa´ão();

} catch (SQLException e) {

System.out.println("Erro ao salvar um cliente. " + e.getMessage());

}

}

 

public void incluiNoBanco(Cliente c) throws SQLException {

...

banco.execute("INSERT INTO CLIENTE (....) values (....)");

...

}

 

No exemplo, o compilador obriga que a fun´ão salvaObjeto trate a exce´ão SQLException.

6.2 Lan´ando uma exce´ão

 

Para lan´ar uma exce´ão usa-se a instru´ão throw, diferente de throws visto na se´ão anterior. No exemplo abaixo o parâmetro nome da fun´ão setNome necessita estar preenchido e ser diferente de. Caso isso não aconte´a é lan´ada uma exce´ão da classe IllegalArgumentException. Como a java.lang.IllegalArgumentException herda de RunTimeException ela não precisa ser tratada, mas se ocorrer aparecerá o erro para o usuário.

 

public void setNome(String nome) {

if (nome == null || nome.equals("")) {

throw new IllegalArgumentException("Nome deve ser preenchido").

}

this.nome = nome;

}

 

espero que gostaram do meu super tuto

[vinnyastolpho 1]

Muuuuito bom cara, bem explicadinho e levou meu "thanks" :cool: