Concorde

PRINCÍPIOS DA AVIAÇÃO

A Sustentação

A sustentação é, resumidamente, o que faz o avião levantar vôo e permanecer no ar. A sustentação é formada por uma diferença de pressão entre a parte inferior e a parte superior das asas, mas não entre em pânico! O conceito é bem simples. O fluxo de ar que passa pelas asas é “cortado em dois” ao atravessá-las. Uma parte do fluxo de ar passa por baixo das asas e força a parte inferior das asas para cima, criando uma grande pressão nessa parte, que tende a levantar a asa. Quanto mais reta e uniforme for a parte inferior das asas de um avião, mais pressão será gerada pelo ar que por ali passa, aumentando a sustentação.

Mas só a pressão gerada pelo fluxo de ar inferior não é o suficiente para fazer o avião voar. O fluxo de ar que passa pela parte superior da asa não pode exercer muita pressão sobre a asa, porque, ao contrário do fluxo de ar inferior, a pressão gerada pelo ar que passa por cima da asa não empurra o avião para cima, e sim para baixo. Isso foi resolvido pelo acréscimo de uma curva na asa. Essa curva funciona porque as duas correntes de ar sempre voltam a se unir após passarem pela asa. Assim, a corrente inferior precisa percorrer uma distância menor que a corrente superior e, consequentemente, tem uma velocidade menor, o que lhe permite exercer mais pressão, enquanto a corrente superior tem uma velocidade maior e exerce uma pressão menor. O princípio de que uma corrente de ar a velocidades maiores exerce menos pressão do que uma corrente de ar a uma velocidade menor se chama Princípio de Bernoulli.  A explicação pode ser meio complicada para pessoas que não tem conhecimento avançado em física, mas é basicamente isso: Quando o ar  começa a se mover, os átomos presentes no ar tem uma determinada velocidade. Quando o ar se move lentamente, parte dessa velocidade é utilizada para “acompanhar o grupo de átomos”, por assim dizer, e o resto é desperdiçado em movimentos desordenados que acabam em colisões com outros átomos, o que cria pressão na superfície em que o ar se move. Mas quando o ar está a uma alta velocidade, a maior parte da velocidade de cada átomo é utilizada para “acompanhar o grupo”, diminuindo as colisões e a pressão gerada. Poderíamos dizer que em um movimento de alta velocidade os átomos não tem tempo para colidirem uns com os outros. Se você quiser saber mais, recomendo essa página: http://home.earthlink.net/~mmc1919/venturi.html

A PERDA DE SUSTENTAÇÃO E OS FLAPS

Os aviões precisam adquirir uma velocidade muito alta para que a sustentação seja a suficiente para fazê-lo levantar voo. Por isso é que os aviões sempre precisam percorrer uma longa distância antes de decolar. Você já notou que toda vez que um avião decola ou aterrissa uma estrutura da asa se abaixa? Esses são os flaps. A função dos flaps é aumentar ou diminuir a sustentação, precisando ser utilizados na decolagem, aterrissagem e em manobras para desviar o avião. Seu papel na decolagem e aterrissagem é simples. Os flaps abaixam, aumentando a sustentação, o que permite que o avião mantenha a sustentação a velocidades mais baixas, podendo decolar e aterrissar a uma velocidade menor do que a que seria necessária sem os flaps. Quando o avião é desviado para uma certa trajetória, o flap da asa que está na direção à qual se pretende desviar levanta, diminuindo a sustentação dessa asa, enquanto o flap da asa na direção oposta abaixa, aumentando a sustentação. Durante essa operação, o avião fica inclinado e tende a se desviar para o lado da asa em que o flap está levantado.

O EMPUXO

A sustentação só tem um efeito considerável no avião a uma determinada velocidade. Por isso é que todos os aviões(exceto alguns modernos aviões militares que tem sistema de decolagem e aterrissagem vertical) precisam percorrer longas distâncias e atingir certa velocidade para levantar voo. Nos aviões que utilizam hélices ou turbinas, essa velocidade é adquirida pela ação de uma força chamada empuxo. O empuxo pode ser entendido desse jeito: Ao girarem, as turbinas “puxam” o ar para trás. Segundo Isaac Newton, “toda ação produz uma reação no sentido contrário”. Portanto, a ação de “puxar” o ar para trás produz uma reação no sentido contrário, sendo o resultado disso o empuxo, que empurra o avião para frente. A ação de “puxar” o ar para trás é chamada de Arrasto, sendo esta uma força oposta ao empuxo.

A FORMA AERODINÂMICA

Por último, e talvez o conceito mais fácil de se entender, é o design aerodinâmico do avião. Não é por acaso que todos os aviões comerciais, jatos privados e a maioria dos aviões militares possuem um formato parecido, com o tronco do avião arredondado, parecendo uma espécie de pílula. Essa forma é crucial para a aerodinâmica do avião, já que é responsável por desviar o ar do corpo do avião gerando a menor resistência e atrito possíveis. A velocidade máxima de um avião também está intimamente ligada com sua forma aerodinâmica. Se o design aerodinâmico é ruim, a resistência do ar será maior, e essa resistência é multiplicada por 4 toda vez que a velocidade dobra, retardando o avião. Isso significa que se o design aerodinâmico não for bom, a potência do motor e das turbinas não importa, porque a resistência do ar sempre irá impor uma barreira para o aumento da velocidade do avião.

Filed under: Aviação Tagged: aerodinâmica, aeronáutica, ar, arrasto, arredondado, asa, aviação, avião, Bernoulli, Boeing, Concorde, curva, design, diferença, empuxo, engenharia, entrada, faz, flap, Fluxo, força, funcionamento, o, perda, pressão, principio, principios, que, resistência, sustentação, turbina, voar ]]> http://codewars.wordpress.com/2010/10/04/principios-da-aviacao/feed/ 0 Gamma Radiation Concorde sustentacao giro empuxo designaerodinamico http://codewars.wordpress.com/2009/10/06/code-wars-blog-sera-atualizado-com-menos-frequencia/ http://codewars.wordpress.com/2009/10/06/code-wars-blog-sera-atualizado-com-menos-frequencia/#comments Tue, 06 Oct 2009 13:23:11 +0000 Gamma Radiation http://codewars.wordpress.com/?p=273 ]]> Bem, eu poderia fazer alguns tutorias básicos sobre Java, C++ ou HTML, mas não faz muito sentido, já que existem ótimos tutoriais sobre isso na Internet.

Gênero: Hard Rock

Banda: Guns n Roses

Música: Paradise City

WEBBROWSER

Um dos únicos que não está “escondido” e disponível na toolbox de cara. Você pode criar um browser simples com apenas algumas linhas de código. Parece ser o coração do Internet Explorer, porque aqui a fonte do título do meu site apareceu desconfigurada do mesmo jeito nesse browser e no IE. Apesar de algumas incompatibilidades e uma funcionalidade extremamente limitada, esse browser é bem rápido. Se quiser criar seu próprio browser “homemade” siga esse vídeo:

MEDIA PLAYER

Bem, eu so achei tutoriais sobre esse componente em Visual Basic, porém muito pouco muda em C++. Inicie um projeto de Forms no Visual C++. Este componente não está na toolbox por default, então vá em Tools, Choose toolbox items, procure Windows Media Player na aba COM e marque sua checkbox. Arraste para a janela o Media Player e o File Chooser Dialog. Clique duas vezes no Media Player e adicione esse código:

axWindowsMediaPlayer1->URL = openFileDialog1->FileName;

Agora volte ao Design da Form, clique duas vezes no File Chooser e adicione esse código:

openFileDialog1->ShowDialog();

Pronto! Já tem um Media Player funcionando. Se quiser ver o vídeo do Visua Basic aqui está:

COMPLICAÇÕES

NANOMOTORES

Bem, como poderíamos fazer para um robô com muito menos de um milímetro se movimentar? Detalhe: No mundo dos nanorobôs, aqueles princípios da Física que te pareceram malucos valem, como o movimento browniano, então o nanomotor deve ter força o bastante para vencer esse movimento. Pense bem. Se o motor for elétrico, será preciso conseguir uma fonte de eletricidade para ele. Se for um esquema simplificado e em miniatura dos motores de carros precisaria de combustível. E então? A resposta é criar um mecanismo que consegue energia de um a fonte comum e natural. Água! Cientistas já tem uma idéia de como criar o mecanismo, e seu nome é mecanismo catalítico, vamos analisá-lo: O nanorobô se auto-impulsionaria  por água e água-oxigenada empurrando o fluido pela lateral através de reações químicas(não vou entrar em detalhes porque há mais coisas a falar), superando a viscosidade aquosa. Perfeito não é? O nanorobô estaria mergulhado no próprio combustível dentro do corpo humano. Mas isso é só parte do problema. Precisamos também manter o nanorobô controlado e com uma rota uniforme para chegar ao seu objetivo. Está um estudo o uso de nanobússolas para fazer o robô se mover perpendicularmente ao campo magnético, evitando que se mova aleatoriamente ou sofra giros por causa do movimento browniano. Agora só faltam os circuitos para controlá-los. Abaixo um esquema de mecanismo catalítico:

NANOCATÁSTROFES

Imagine o seguinte: Cientistas conseguem criar um nanorobô que consegue se autoreplicar e o testam pela primeira vez para construir um tijolo(hehe). Mas algo dá terrivelmente errado! Os nanorobôs não param de se replicar e rapidamente o país inteiro está preenchido por nanorobôs, e depois ocupariam o planeta inteiro, uma cena parecida com a quase-destruição da Terra em O Dia em que a Terra parou. nanorobôs que se auto-replicam poderiam servir para inúmeras funções. Mas esse tipo de nanorobôs deve ser intensamente estudad0 antes de ser posto em prática. Outro perigo é a facilitação da criação de vírus modificados para destruir a humanidade por terroristas ou qualquer outro mecanismo de destruição em massa facilitado pela nanotecnologia.

Não, isso não é um avião derrubando o prédio e sim, nanorobôs!

PROMESSAS

NANOMEDICINA

Se conseguirmos dominar a nanotecnologia, a medicina sofrerá uma revolução. Poderíamos usar nanorobôs programados especialmente para combater uma determinada doença, portanto, esqueça quimioterapia e etc…, porque os nanorobôs identificarão e destruirão apenas as células cancerosas. Nós também poderemos ser imortais, ou super-humanos. Segundo teses, o envelhecimento é apenas o acúmulo de erros aleatórios no organismo, e os nanorobôs poderão corrigi-las daqui a algum tempo.

AVANÇOS TECNOLÓGICOS

Bem, se dominarmos a nanotecnologia completamente poderemos ter gadgets tecnológicos de qualquer tamanho e computadores absurdamente potentes. Use sua imaginação, pois praticamente qualquer tipo de equipamento tecnológico poderá ser feito.

Publicado emTecnologia Tagged: auto-replicam, browniano, campo, catalítico, catástrofes, câncer, combate, complicações, dia, doenças, Física, magnético, maluca, mecanismo, medicina, motor, movimento, nano, nanomedicina, nanomotor, nanorobôs, nanotecnologia, orientação, parou, promessas, replicam, robôs, Tecnologia, terra, terroristas ]]> http://codewars.wordpress.com/2009/09/29/nanotecnologia-promessas-e-complicacoes/feed/ 0 Gamma Radiation Nano Nanomotor Nanorobos_dia_terra_parou Nanomed Nanotech http://codewars.wordpress.com/2009/09/26/musica-da-semana/ http://codewars.wordpress.com/2009/09/26/musica-da-semana/#comments Sat, 26 Sep 2009 01:53:47 +0000 Gamma Radiation http://codewars.wordpress.com/?p=247 ]]> Para descontrair um pouco, estou lançando uma série de posts semanais com uma música legal. Aí vai a primeira:

Cantada por: Judas Priest

Gênero: Heavy Metal

Digam-me o que acham!

O arquivo(doc) para baixar segue abaixo:

http://www.4shared.com/file/135075457/7ecd790f/palavras_reservadas.html

A TEORIA QUÂNTICA E O CAMPO DE MAXWELL

Ao tentar estender a Mecânica Quântica ao campo de Maxwell(Conjunto de leis eletromagnéticas), acharam alguns problemas. Vamos analisar isso. O campo de Maxwell pode ser descrito como constituído por ondas de diferentes comprimentos, nas quais o campo oscilará de um valor para outro. Porém, segundo a teoria Quântica, seria impossível esse campo estar em repouso, pois violaria o Princípio da Incerteza. Então o campo deveria estar em uma posição e velocidade incerta, e esses princípios também valem para as ondas desse campo, que mesmo no estado fundamental também não poderiam ter sua posição  e velocidade exatamente medida. Cálculos dessas flutuações no Campo de Maxwell tornavam a massa e carga dos elétrons infinitas, criando uma contradição. Foram elaboradas várias “correções” para isso, incluindo até uma Constante Cosmológica Quântica! As Teorias que mais se destacaram após esse momento foram a Super Gravidade com 11 dimensões e a Teoria das Supercordas, que veremos a seguir.

A SUPERSIMETRIA E A SUPERGRAVIDADE

A Supersimetria pode ser descrita com um modelo matemático que acrescenta mais dimensões ao espaço-tempo além das em que vivemos. Essas dimensões extra são chamadas de Dimensões de Grassman, porque são medidas com os números de Grassman, números em que a ordem dos fatores altera o produto em uma multiplicação. Essa Supersimetria é um mecanismo físico natural para cancelamento de infinitos, e é a base da Super Gravidade com 11 dimensões. A SupeSimetria, porém, possui uma consequência: cada partícula precisa de um SuperParceiro com spin metade maior ou menor do que o seu. O spin de uma partícula é simplesmente a sua aparência em diferentes direções. Por exemplo, a partícula abaixo com spin 1 deve ser rodada 360 graus para voltar a ter a aparência inicial, e a outra com spin 2 deve ser rodada 180 graus para voltar e ter a aparência original. Existem também partículas com spin 1/2, que devem ser rodadas 720 graus para voltar a ter a aparência original.

Portanto, como a Supersimetria é a base da Super Gravidade era de se esperar encontrarmos algum tipo de partículas ocm Super Parceiros. Segundo a Teoria da Super Gravidade tudo que vemos é formado por férmions ou bósons. Férmions possuem spins semi-inteiros(1/2) e constituem a matéria, e bósons spins inteiros(1, 2…) e constituem forças entre os férmions, como a gravidade. Férmions são negativos basicamente e bósons positivos. Todo férmion ou bóson possui um Super Parceiro com spin metade maior ou menor do que o seu próprio. Essa teoria cancelariam os infinitos apresentados no Campo de Maxwell porque os férmions que são negativos cancelariam as forças positivas dos bósons, eliminando infinitos.

A TEORIA DAS CORDAS

Segundo a Teoria das Cordas, não são partículas que formam tudo o que existe, mas sim Cordas! Essas cordas vibrariam e suas diferentes vibrações seriam interpretadas como partículas, e se as cordas possuíssem dimensões de Grassman, poderiam vibrar de um modo que as vibrações fossem interpretadas como bósons e férmions, o que deixaria a Teoria livre dos infinitos. Mas de repente, físicos constataram que haviam cinco diferentes Teorias das Cordas e não era o suficiente para representar a curvatura do espaço-tempo. Os físicos então descobriram que a Teoria das Cordas era apenas uma parte de uma teoria maior. Essa Teoria maior foi intitulada de Teoria M, por ser misteriosa, a mãe de todas as teorias e até mágica e mística! Essa teoria abrangeria as cinco teorias das SuperCordas mais a Super Gravidade com 11 dimensões, porém, muitas das propriedades dessa teoria são desconhecidas. E aqui estamos. Hoje estamos montando o quebra-cabeça da Teoria M, e parece  que dessa vez estamos certos! Abaixo a Teoria-M abrangendo as Teorias das Cordas e Super Gravidade:

CONCLUSÃO

Achar uma Teoria do Tudo é muito difícil. Diversas Teorias foram destruídas ou modificadas por minúsculas contradições, e é extremamente difícil achar uma Teoria que não apresente contradições ou erros. Porém, os físicos nunca deixaram de questionar, o que é o mais importante segundo Einstein, e conseguiram chegar a promissora Teoria-M, e dessa vez devemos achar uma resposta! A informação para estes artigos foi tirada do livro de Stephen Hawking: O Universo numa Casca de Noz.

// Cabeçalhos necessários
#include <windows.h>
#include <stdlib.h>

LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

// WinMain, a função main em janelas
int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nFunsterStil)
{

HWND hwnd;      // O objeto para indicar a janela
MSG messages;   // Objeto mensagem do Windows para controlar o acionamento de botões
WNDCLASSEX wincl;   // O objeto para criar a janela

wincl.hInstance = hThisInstance;
wincl.lpszClassName = “WindowsAppl”; // Nome da classe da janela
wincl.lpfnWndProc = WindowProcedure;
wincl.style = CS_DBLCLKS;
wincl.cbSize = sizeof (WNDCLASSEX);
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);      // Janela com icone default do Windows
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);          //Cursor default
wincl.lpszMenuName = NULL;
wincl.cbClsExtra = 0;
wincl.cbWndExtra = 0;
wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;       // Cor cinza de background

if (!RegisterClassEx (&wincl))  // Se o registro da classe foi mal-sucedido return 0
return 0;

hwnd = CreateWindowEx (               // Criação da janela
0,
“WindowsAppl”,                 // Indicação da classe da janela
“Hello World”,                 // Nome da janela
WS_OVERLAPPEDWINDOW,           // Estilo da janela
350,                               // x em relação ao desktop
250,                                 // y em relação ao desktop
300,                                  // largura da janela
300,                               // altura da janela
HWND_DESKTOP,
NULL,
hThisInstance,
NULL
);

ShowWindow (hwnd, nFunsterStil);                // Mostrar a janela

while (GetMessage (&messages, NULL, 0, 0)) // Recuperar mensagens
{
TranslateMessage(&messages);
DispatchMessage(&messages);
}

return messages.wParam;
}

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_CREATE: // Criação da janela
break;
case WM_COMMAND:   // Interpretação da janela
break;
case WM_DESTROY:   // Destruição da janela
PostQuitMessage (0);
break;
default:
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}

O cabeçalho #include<windows.h> é obrigatório em qualquer aplicação que use janelas no Windows. O outro cabeçalho(stdlib.h) contém a biblioteca de funções do Windows e C++. Depois iniciamos uma Procedure do Windows e a função WinMain, que configura, cria e deixa visível a janela. Dentro dessa função precisamos definir uma variável HWND para a janela, uma variável MSG para armazenar as ações do usuário e da janela e uma variável WNDCLASSEX para configurar e criar a janela. A seguir podemos ver a variável wincl que definimos anteriormente chmando variáveis de configuração. Entre elas, podemos ver algumas importantes como lpszClassName, que define o nome da classe da janela, as outras importantes se tiver interesse pode ver nos comentários do código. Depois verificamos se a classe foi registrada com sucesso e criamos a janela com a função CreateWindowEx, pode ver os parâmetros importantes dessa função nos comentários. Depois mostramos a janela, recuperamos a variável messages determinada anteriormente, e agora uma parte importantíssima, que é a definição do WindowProcedure, a função chamada quando o usuário interage com a janela. Dentro da WindowProcedure temos um switch, e quando a condição é WM_CREATE a janela é criada, quando a condição é WM_COMMAND é porque o usuário interagiu com um componente da janela, e quando é WM_DESTROY é porque a janela foi destruída! A única dessas condições com algo além de break por enquanto é a WM_DESTROY, em que chamamos a função PostQuitMessage para destruir a janela. Aperte f9 para compilar. Isso é o que deve aparecer:

COLOCANDO OS COMPONENTES

Criamos uma janela vazia. Agora é hora de colocar os componentes!  Precisaremos de dois Textbox para a entrada dos valores dos catetos, um botão para acionar, duas labels para indicar os campos do cateto a e cateto b, e após o cálculo ser completado, disparar uma MessageBox com o resultado. Cole esse código acima da função WindowProcedure:

#define BUTTONOK 10

HINSTANCE g_inst;
HWND Cateto1, Cateto2, ButtonOk;

void DrawComponents(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {

CreateWindowEx (
0,
“STATIC”,
“Cateto a”,
WS_VISIBLE|WS_CHILD,
30, 20, 60, 20,
hwnd,
NULL,
g_inst,
NULL
);
Cateto1 = CreateWindowEx (
WS_EX_CLIENTEDGE,
“EDIT”,
“”,
WS_VISIBLE|WS_CHILD|WS_BORDER,
30, 50, 50, 20,
hwnd,
NULL,
g_inst,
NULL
);

CreateWindowEx (
0,
“STATIC”,
“Cateto b”,
WS_VISIBLE|WS_CHILD,
30, 80, 60, 20,
hwnd,
NULL,
g_inst,
NULL
);

Cateto2 = CreateWindowEx (
WS_EX_CLIENTEDGE,
“EDIT”,
“”,
WS_VISIBLE|WS_CHILD|WS_BORDER,
30, 110, 50, 20,
hwnd,
NULL,
g_inst,
NULL
);

ButtonOk = CreateWindowEx (
0,
“BUTTON”,
“Ok”,
WS_VISIBLE|WS_CHILD,
40, 140, 20, 20,
hwnd,
(HMENU)BUTTONOK,
g_inst,
NULL
);

}

Dentro da função WindowProcedure e do switch, chame essa função que acabamos de criar desse modo dentro do WM_CREATE:

DrawComponents(hwnd,message,wParam,lParam);

Com esse código criamos uma função para desenhar os componentes na janela, e podemos ver a função CreateWindowEx ser chamada, mas dessa vez, com parâmetros diferentes. Os parâmetros mais importantes são: o segundo(tipo do componente), o terceiro(texto do componente), o quarto(Definição de que o componente será visível e filho da janela), o quinto(distância da esquerda), sexto(distância do topo), sétimo(largura do componente), e oitavo(altura do componente). Podemos também ver a declaração de algumas variáveis HWND, que guardarão os dados das Textbox e do botão, para sabermos seus valores e se foram acionados. O botão precisa excepcionalmente de um ID, criado com #define anteriormente. Finalmente chamamos a função que criamos e informamos os parâmetros definimos na função WinMain. Aperte f9 e deverá ver isso:

CRIANDO A LÓGICA DA APLICAÇÃO

Agora que já criamos todos os componentes, devemos calcular a hipotenusa. Inclua no seu programa o cabeçalho math.h para podermos calcular a raiz quadrada. Agora copie esse código para dentro do WM_COMMAND no switch do WindowProcedure.

if ((HIWORD(wParam) == BN_CLICKED))
{

SendMessage(
(HWND) Cateto1,
(UINT) EM_GETLINE,
(WPARAM) 1,
(LPARAM) &Cat1
);

SendMessage((HWND)Cateto2,(UINT)EM_GETLINE,(WPARAM)1,(LPARAM) &Cat2);

CatetoA = atoi(Cat1);
CatetoB = atoi(Cat2);
int Hipotenusa_quadrado = CatetoA*CatetoA + CatetoB*CatetoB;
hipotenusa = sqrt(Hipotenusa_quadrado);

itoa (hipotenusa,Hipot,10);

MessageBox (NULL, Hipot, “Resultado”, MB_OK);
}

Antes da função WindowProcedure também copie essas variáveis:

char Cat1[20] = “0″, Cat2[20] = “0″, Hipot[20] = “0″;
int CatetoA, CatetoB, hipotenusa;

Neste código colocamos uma condição if(HIWORD == BN_CLICKED) para determinar se o botão foi clicado. Se foi o código abaixo do if será executado. Com a função SendMessage nós recuperamos o texto digitado nas duas textBox e iniciamos duas variáveis String determinadas anteriormente com o seu valor. Depois fazemos uma conversão de String para int coma  função atoi e finalmente calculamos a hipotenusa! Mas ainda não acabou. Precisamos converter de int para String para podermos mostrar o resultado em uma MessageBox. Agora sim! Abaixo seguem a imagem do programa em ação e o link para download do código:

Download Source

CONCLUSÃO

O que levaria cinco linhas de código para fazer no Visual C++ levou mais de 100 no Dev C++. Programar janelas em C++ sem usar facilitadores como os do Visual C++ gasta muito mais tempo, mas em compensação é mais flexível e deixa o programa mais rápido. Recomendo programar assim apenas programas que realmente necessitem desse tipo de programação.

<EditText android:id=”@+id/Altura” android:layout_height=”wrap_content” android:layout_width=”wrap_content”></EditText>
<EditText android:id=”@+id/Comprimento” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></EditText>
<Button android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:id=”@+id/Ok” android:text=”Ok”></Button>

Agora que já temos tudo configurado precisamos recuperar os valores dos EditText e definir o que acontecerá quando o botão for clicado. Mas antes vamos criar a Activity que exibirá o resultado do cálculo da área. Vá em File -> New -> File, digite activity2 como nome e selecione o pacote em que está trabalhando. Agora digite esse código na Activity principal, abaixo do setContentView:

         final EditText comprimento = (EditText) findViewById(R.id.altura);
	 final EditText altura = (EditText) findViewById(R.id.comprimento);
	 final Intent it = new Intent(this, activity2.class);
	 Button b = (Button) findViewById(R.id.Ok);
	 b.setText("Clique para calcular a área!");
	 b.setOnClickListener(new Button.OnClickListener() {
		 public void onClick(View v) {
	int comprimentoi = Integer.parseInt(comprimento.getText().toString());
	int alturai = Integer.parseInt(altura.getText().toString());
	it.putExtra("values", "E o resultado é: " + alturai * comprimentoi);
	startActivity(it);
		 }
	 });

Aqui nós recuperamos os valores definidos em main.xml com o método findViewById e colocamos um Listener para o botão b, que recuperou o valor do botão ok no arquivo main. No método onClick, que possui o código a ser executado quando o botão for clicado, há apenas uma conversão para int dos valores dos EditText, e, mais importante, um parâmetro foi posto no Intent it pelo método putExtra e a activity activity2 foi iniciada pelo método startActivity.

RECUPERANDO PARÂMETROS

Agora só precisamos exibir o parâmetro do Intent it na activity2. Copie esse código para o método onCreate da activity2:

                TextView view = new TextView(this);
                view.setText("");
		Intent it = getIntent();
		if(it != null) {
			String msg = it.getStringExtra("values");
			if(msg != null) {
				view.setText(msg);
			}
		}
		setContentView(view);

Criamos uma nova TextView para exibir os valores, criamos um novo Intent para capturar o Intent que o direcionou para esta Activity, verificamos sua validade, configuramos uma String para achar o parâmetro String “values” passado pela Activity anterior e finalmente configuramos o texto para exibir essa String! Agora está tudo pronto! Abaixo vemos a aplicação em ação: