miércoles, 24 de junio de 2009

Prueba Final


import java.applet.Applet;
import java.awt.*;
import javax.swing.JApplet;
import javax.swing.JOptionPane;

public class Prueba extends Applet {
public void init(){
}
public void paint(Graphics g){
String aux=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DEL RADIO","RADIO",JOptionPane.DEFAULT_OPTION);
double radio=Double.parseDouble(aux);
String aux2=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DEL ANGULO","ANGULO",JOptionPane.DEFAULT_OPTION);
double alfa=Double.parseDouble(aux2);
String aux3=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA VELOCIDAD X ","VX",JOptionPane.DEFAULT_OPTION);
double vx=Double.parseDouble(aux3);
String aux4=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA VELOCIDAD Y","VY",JOptionPane.DEFAULT_OPTION);
double vy=Double.parseDouble(aux4);
String aux5=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA ACELERACION X","AX",JOptionPane.DEFAULT_OPTION);
double ax=Double.parseDouble(aux5);
String aux6=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA ACELERACION Y","AY",JOptionPane.DEFAULT_OPTION);
double ay=Double.parseDouble(aux6);
String aux7=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DEL TIEMPO","t",JOptionPane.DEFAULT_OPTION);
double t=Double.parseDouble(aux7);

double angulo;
double wf= alfa/t;
double aceAngular=(wf/t);
double modVo= Math.sqrt((vx*vx)+(vy*vy));
double vf= ((wf*radio)+modVo);
double yf= radio*Math.sin((180-alfa)*Math.PI/180);
double xf= radio*Math.cos((180-alfa)*Math.PI/180);

g.setColor(Color.RED);
g.drawOval(40, 73, (int) radio*10,(int)radio*10);
g.setColor(Color.BLUE);
g.drawOval((int)(60-xf+2*radio),(int)(60-yf+2*radio), (int)radio,(int)radio);
g.drawString("115º", 68, 60);
g.setColor(Color.GREEN);
g.drawOval(88, 119, 5, 5);
g.setColor(Color.BLACK);
g.drawString("VEL ANGULAR(Wf)", 180,45);
g.drawString(""+wf, 312,45);
g.drawString("VEL TANGENCIAL(Vf)", 180,60);
g.drawString(""+(int)vf, 312,60);
g.drawString("ACEL ANGULAR", 180,75);
g.drawString(""+aceAngular, 312,75);
g.drawString("TIEMPO", 180,90);
g.drawString(""+t, 312,90);
g.drawString("ANGULO", 180,105);
g.drawString(""+alfa, 312,105);
g.drawString("RADIO 10m", 180,120);
g.drawString("ACELERACION X -2,5", 180,135);
g.drawString("ACELERACION Y -1,8", 180,150);
g.drawString("VELOCIDAD X -10", 180,165);
g.drawString("VELOCIDAD Y -20", 180,180);
}
}

lunes, 8 de junio de 2009

Dinamica


import java.applet.Applet;
import java.awt.*;
import javax.swing.JApplet;
import javax.swing.JOptionPane;

public class Dinamica extends Applet {
public void init(){
}
public void paint(Graphics g){
String aux=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA BASE","BASE",JOptionPane.DEFAULT_OPTION);
double base=Double.parseDouble(aux);
String aux2=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA ALTURA","ALTURA",JOptionPane.DEFAULT_OPTION);
double altura=Double.parseDouble(aux2);
double angulo;

g.drawLine(30,150,(int) base+30,150 );
g.drawLine((int)base+30, 150,(int)base+30,150-(int)altura);
g.drawLine(30, 150, (int)base+30, 150-(int)altura);
double tan=altura/base;
angulo=Math.atan(tan);
angulo=Math.toDegrees(angulo);

String aux8=JOptionPane.showInputDialog(null,"INGRESE LA DISTANCIA a DE LA MASA","INGRESE DISTANCIA a",JOptionPane.DEFAULT_OPTION);
double ab=Double.parseDouble(aux8);
double c=ab*Math.cos(angulo*Math.PI/180);
double xo=30+c;
double l=ab*Math.sin(angulo*Math.PI/180);
double yo=150-l;
double d=20*Math.cos(angulo*Math.PI/180);
double xo1=xo+d;
double m=(c+d)*Math.tan(angulo*Math.PI/180);
double yo1=150-m;
g.setColor(Color.RED);
g.drawLine((int)xo,(int)yo,(int)xo1,(int)yo1);
double dx=10*Math.sin(angulo*Math.PI/180);
double dy=10*Math.cos(angulo*Math.PI/180);
double xo2=xo1-dx;
double yo2=yo1-dy;
g.drawLine((int)xo1,(int)yo1,(int)xo2,(int)yo2);
g.drawLine((int)xo2,(int)yo2,(int)(xo-dx),(int)(yo-dy));
g.drawLine((int)(xo-dx),(int)(yo-dy),(int)xo,(int)yo);

String aux3=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA FUERZA","FUERZA EN NEWTONS",JOptionPane.DEFAULT_OPTION);
double fuerza=Double.parseDouble(aux3);
String aux4=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA MASA","MASA EN KILOGRAMOS",JOptionPane.DEFAULT_OPTION);
double masa=Double.parseDouble(aux4);

String aux5=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DEL COEFICIENTE DE ROZAMIENTO","COEFICIENTE DE ROZAMIENTO",JOptionPane.DEFAULT_OPTION);
double niu=Double.parseDouble(aux5);

String aux6=JOptionPane.showInputDialog(null,"INGRESE EL TIEMPO","TIEMPO EN SEGUNDOS",JOptionPane.DEFAULT_OPTION);
double tiempo=Double.parseDouble(aux6);

double gravedad=9.8;
double aceleracion;
aceleracion=(fuerza/masa)-(gravedad*((niu*Math.cos(angulo*Math.PI/180))+Math.sin(angulo*Math.PI/180)));
double desplazamiento= aceleracion*0.5*tiempo*tiempo;
double xn=desplazamiento*Math.cos(angulo*Math.PI/180);
double yn=desplazamiento*Math.sin(angulo*Math.PI/180);
g.setColor(Color.BLUE);
g.drawLine((int)(xo+xn),(int)(yo-yn), (int)(xo1+xn), (int)(yo1-yn));
g.drawLine((int)(xo1+xn),(int)(yo1-yn),(int)(xo2+xn),(int)(yo2-yn) );
g.drawLine((int)(xo2+xn),(int)(yo2-yn),(int)(xo+xn-dx),(int)(yo-yn-dy) );
g.drawLine((int)(xo+xn-dx),(int)(yo-yn-dy),(int)(xo+xn),(int)(yo-yn) );
g.setColor(Color.GREEN);
double yb=5*Math.sin((angulo)*Math.PI/180);
double xb=5*Math.cos((angulo)*Math.PI/180);
double frx=0.1*miu*masa*gravedad*Math.cos(angulo*Math.PI/180);
double fry=0.1*miu*masa*gravedad*Math.sin(angulo*Math.PI/180);
g.drawLine((int)(xo+xn-xb+(0.5*d)),(int)(yo-yn-yb-dx),(int)(xo+xn-xb+(0.5*d)-frx),(int)(yo-yn-yb-dx+fry) );
g.drawString("fr",(int)(xo+xn-xb+(0.5*d)-frx-15),(int)(yo-yn-yb-dx+fry));

g.setColor(Color.BLUE);
double ny=0.1*masa*gravedad*Math.cos(angulo*Math.PI/180);
double nx=0.1*masa*gravedad*Math.sin(angulo*Math.PI/180);
g.drawLine((int)(xo+xn-xb+(0.5*d)),(int)(yo-yn-yb-dx),(int)(xo+xn-xb+(0.5*d)-nx),(int)(yo-yn-yb-dx-ny) );
g.drawString("FN",(int)(xo+xn-xb+(0.5*d)-nx-20),(int)(yo-yn-yb-dx-ny));
g.setColor(Color.cyan);
double fx=0.1*fuerza*Math.cos(angulo*Math.PI/180);
double fy=0.1*fuerza*Math.sin(angulo*Math.PI/180);
g.drawLine((int)(xo+xn-xb+(0.5*d)),(int)(yo-yn-yb-dx),(int)(xo+xn-xb+(0.5*d)+fx),(int)(yo-yn-yb-dx-fy) );
g.drawString("F",(int)(xo+xn-xb+(0.5*d)+fx-15),(int)(yo-yn-yb-dx-fy));

g.setColor(Color.green);
double peso=0.1*masa*gravedad;
g.drawLine((int)(xo+xn-xb+(0.5*d)),(int)(yo-yn-yb-dx),(int)(xo+xn-xb+(0.5*d)),(int)(yo-yn-yb-dx+peso) );
g.drawString("P",(int)(xo+xn-xb+(0.5*d)-15),(int)(yo-yn-yb-dx+peso));

g.drawLine(200,30,200,150);
g.drawLine(200,150,350,150);
g.drawLine(350,150,350,30);
g.drawLine(350,30,200,30);
for(int i=0;i<8;i++){
g.drawLine(200,30+(15*i),350,30+(15*i));
}
g.drawLine(320, 30, 320, 150);
g.setColor(Color.RED);
g.drawString("FUERZA", 202,44);
g.drawString(""+fuerza, 322,44);
g.drawString("MASA", 202,59);
g.drawString(""+(int)masa, 322,59);
g.drawString("TIEMPO", 202,74);
g.drawString(""+tiempo, 322,74);
g.drawString("NIU", 202,89);
g.drawString(""+niu, 322,89);
g.drawString("ACELERACION", 202,104);
g.drawString(""+(short)aceleracion, 322,104);
g.drawString("DESPLAZAMIENTO", 202,119);
g.drawString(""+(short)desplazamiento, 322,119);
g.drawString("FUERZA NORMAL", 202,134);
g.drawString(""+(short)(niu*masa*gravedad*Math.cos(angulo*Math.PI/180)), 322,134);
g.drawString("ANGULO PLANO", 202,149);
g.drawString(""+(short)angulo, 322,149);
}
}

miércoles, 3 de junio de 2009

Termometro


import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JApplet;
import javax.swing.JOptionPane;
import javax.swing.JOptionPane.*;

public class Termometro extends JApplet {
public void init(){
}
public void paint(Graphics g){
g.drawRect(200, 50, 20, 100);
g.drawOval(20, 30, 50, 50);
g.drawOval(30, 80, 100, 100);
g.drawString("0ºC", 230, 150);
g.drawString("100ºC", 230, 50);
g.drawString("0ºC", 138,135);
g.drawString("50ºC", 3,135);
g.drawString("75ºC", 70,198);
String aux=JOptionPane.showInputDialog(null,"Ingrese valor de temperatura","Termometro",JOptionPane.DEFAULT_OPTION);
int temp = Integer.parseInt(aux);
double cir =(double)temp*3.6;
g.drawString("+" +temp+ "ºC", 230, 150-temp);
g.setColor(Color.BLUE);
if (temp>80){
g.setColor(Color.RED);
g.fillOval(20, 30, 50, 50);
g.fillRect(200, 50, 20, 100-temp);
g.drawString("Alerta", 30, 10);
}
g.fillOval(20, 30, 50, 50);
g.fillRect(200, 50, 20, 100-temp);
g.fillArc(30, 80, 100, 100,0,(int)(cir));
}
}

lunes, 1 de junio de 2009

Paneles 2

import java.awt.*;
import javax.swing.JOptionPane;
public class Demopanel2 extends JFrame{
Container contenedor;

private JPanel pmatriz;
private JTextField[][]espacios;
private int numfilas;
private int numcolumnas;

public class Demopanel2 {
public static void main(String args[]){
String aux1="Programa de operaciones con matrices\n Digite\n 1.- Suma\n 2.- Resta\n 3.- Multiplicar";
aux=JOptionPane.showInputDialog(null,aux1,JOptionPane.DEFAULT_OPTION);
double d= Double.parseDouble(aux);
if (d==1){
String aux19="Opcion Suma";
JOptionPane.showMessageDialog(null,(d)+aux19,"La opcion que eligio es:",JOptionPane.DEFAULT_OPTION);}
if(d==2){
String aux19="Opcion Resta";
JOptionPane.showMessageDialog(null,(d)+aux19,"La opcion que eligio es:",JOptionPane.DEFAULT_OPTION);}
if(d==3){
String aux19="Opcion Multiplicacion";
JOptionPane.showMessageDialog(null,(d)+aux19,"La opcion que eligio es:",JOptionPane.DEFAULT_OPTION);}

String aux12="Introduzca lo siguiente:";
aux12+="Num Filas\n";
String aux13=JOptionPane.showInputDialog(null,aux12,JOptionPane.DEFAULT_OPTION);
double n= Double.parseDouble(aux13);
JOptionPane.showMessageDialog(null,""+(n),"Num Filas",JOptionPane.DEFAULT_OPTION);
String aux14="Introduzca lo siguiente:";
aux14+="Num Columnas\n";
String aux15=JOptionPane.showInputDialog(null,aux14,JOptionPane.DEFAULT_OPTION);
double o= Double.parseDouble(aux15);
JOptionPane.showMessageDialog(null,""+(o),"Num Columnas",JOptionPane.DEFAULT_OPTION);

numfilas =(int)n;
numcolumnas=(int)o;
contenedor= getContentPane();
espacios=new JTextField[numfilas][numcolumnas];
pmatriz=new JPanel(new GridLayout(numfilas,numcolumnas,3,3));
for(int i=0;i
for(int j=0;j
espacios[i][j]=new JTextField("espacio"+i+" "+j);
pmatriz.add(espacios[i][j]);
}
contenedor.add(pmatriz, BorderLayout.SOUTH);
setSize(700,700);
setVisible(true);
}
}
public static void main(String args[]){
Demopanel2 aplicacion=new Demopanel2();
aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

miércoles, 27 de mayo de 2009

Ejercicio Paneles


import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

public class DemoPanel extends JFrame{
Container contenedor;
private JPanel panelinicio;
private JPanel panelfin;
private JPanel paneli;
private JPanel paneld;
private JButton [][] botones;
private JLabel[][] texto;
private JTextField [][] text;

public DemoPanel(){
super("Campeonato Nacional");
botones = new JButton[3][3];
contenedor = getContentPane();
panelinicio = new JPanel(new GridLayout(3,3,10,10));
String [] equipos = {"Barcelona","Emelec","El Nacional","D.Quito","D.Cuenca","Olmedo","Macara","Manta","Tecnico U."};

int k=0;
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3; j++){
botones[i][j] = new JButton(equipos[k]);
k += 1;
panelinicio.add(botones[i][j]);
}
}
contenedor.add(panelinicio, BorderLayout.NORTH);

texto = new JLabel[5][5];
panelfin = new JPanel(new GridLayout(5,5,10,10));
for(int i = 0; i < 5; i++){
for(int j = 0; j < 5; j++){
texto[i][j]= new JLabel("texto" +i+ " "+j);
panelfin.add(texto[i][j]);
}
}
contenedor.add(panelfin, BorderLayout.SOUTH);

text = new JTextField[4][3];
paneli = new JPanel(new GridLayout(5,5,10,10));
for(int i = 0; i < 4; i++){
for(int j = 0; j < 3; j++){
text[i][j]= new JTextField("texto" +i+ " "+j);
paneli.add(text[i][j]);
}
}
contenedor.add(paneli, BorderLayout.WEST);

text = new JTextField[2][4];
paneld = new JPanel(new GridLayout(5,5,10,10));
for(int i = 0; i < 2; i++){
for(int j = 0; j < 4; j++){
text[i][j]= new JTextField("texto" +i+ " "+j);
paneld.add(text[i][j]);
}
}
contenedor.add(paneld, BorderLayout.EAST);

setSize(425,425);
setVisible(true);
}

public static void main(String args[]){
DemoPanel aplicacion = new DemoPanel();
aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

lunes, 25 de mayo de 2009

Evaluacion Sen,Cos,ax+b


import java.applet.Applet;
import java.awt.*;

public class Evaluacion1 extends Applet {
public void paint(Graphics g){
g.drawString("Función Seno, Funcion Coseno, Recta: ax+b", 150, 55);
g.drawString("y=MSen(ax+b)",300 , 80);
g.drawString("y=MCos(ax+b)",300 , 100);
g.drawString("y=(ax+b)",300 , 120);
g.drawLine(40, 40, 40, 450);
g.drawLine(20, 270, 450, 270);
g.setColor(Color.BLACK);

int a=1;
int b=0;
int m=100;
for(int i=0;i<361; i=i+2)
{
g.fillOval( a*(38 + i)+b,(int) (265 - m*(Math.sin(i*3.1416/180))),6,6);
g.fillOval( a*(38 + i)+b,(int) (265 - m*(Math.cos(i*3.1416/180))),6,6);
g.fillOval( a*(38 + i)+b,(int) 265-(a*i)+b,6,6);
}

g.setColor(Color.GREEN);
g.drawLine(40,165, 398, 165);
g.drawLine(40,370,398,370);
g.drawLine(131,165, 131, 370);
g.drawLine(221,165,221,370);
g.drawLine(311,165, 311, 370);
g.drawLine(401,165,401,370);
g.setColor(Color.BLUE);
g.drawString("-1", 30, 370);
g.drawString("0", 30,270);
g.drawString("1", 30, 165);
g.drawString("¶/2", 115, 280);
g.drawString("¶", 205,280);
g.drawString("3¶/2", 285, 280);
g.drawString("2¶", 405, 280);
g.drawLine(40,40,35,55);
g.drawLine(35,55,45,55);
g.drawLine(45,55,40,40);
g.drawLine(450,270,425,265);
g.drawLine(425,265,425,275);
g.drawLine(425,275,450,270);
g.setColor(Color.MAGENTA);
g.drawString("valores X ", 460, 270);
g.drawString("valores Y ", 25, 35);
int ymax=this.getHeight();
int xmax=this.getWidth();
this.setSize(700, 700);
} }

domingo, 24 de mayo de 2009

Función Seno (Paint)


import java.applet.Applet;
import java.awt.*;

public class FuncionSenApplet extends Applet {
public void paint(Graphics g){
g.drawString("Función seno", 199, 79);
g.drawString("y=Sen(x)",200 , 80);
g.drawLine(40, 40, 40, 450);
g.drawLine(20, 270, 450, 270);
g.setColor(Color.YELLOW);
for(int i=0;i<361; i=i+2){
g.fillOval( 38 + i,(int) (265 - 100*(Math.sin(i*3.1416/180))),6,6);}
g.setColor(Color.GREEN);
g.drawLine(40,165, 398, 165);
g.drawLine(40,370,398,370);
g.drawLine(131,165, 131, 370);
g.drawLine(221,165,221,370);
g.drawLine(311,165, 311, 370);
g.drawLine(401,165,401,370);
g.setColor(Color.BLUE);
g.drawString("-1", 30, 370);
g.drawString("0", 30,270);
g.drawString("1", 30, 165);
g.drawString("¶/2", 115, 280);
g.drawString("¶", 205,280);
g.drawString("3¶/2", 285, 280);
g.drawString("2¶", 405, 280);
g.drawLine(40,40,35,55);
g.drawLine(35,55,45,55);
g.drawLine(45,55,40,40);
g.drawLine(450,270,425,265);
g.drawLine(425,265,425,275);
g.drawLine(425,275,450,270);
g.setColor(Color.YELLOW);
g.drawString("valores X ", 460, 270);
g.drawString("valores Y ", 25, 35);
int ymax=this.getHeight();
int xmax=this.getWidth();
this.setSize(700, 700);
} }

miércoles, 20 de mayo de 2009

Applet trabajo en clase

Sintesis
La Anatomía de un Applet
Un applet Java es un programa que se adhiere a una serie de convenciones que le permiten ejecutarse en un navegador compatible con Java.

Ejemplo: applet "Hello World":
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}

Importar Clases y Paquetes
En el lenguaje Java, los paquetes se usan para agrupar clases, importar Clases y Paquetes nos ofrece más información sobre los paquetes y la sentencia import.

Definir una Subclase de Applet
Todo applet debe definir una subclase de la clase Applet. En el Applet "Hello World", esta subclase se llama HelloWorld. Los applets heredan gran parte de su funcionalidad de la clase Applet.

Implementar Métodos del Applet
Todo applet debe implementar al menos uno de los siguientes métodos: init, start, o paint. Al contrario que las aplicaciones Java, los applets no necesitan implementar un método main.

Ejecutar un Applet
Los applets están pensados para incluirse en páginas HTML. Usando la etiqueta "APPLET", especificamos (como mínimo) la localización de la subclase Applet y las dimensiones de la ventana del applet. Cuando una navegador que soporta Java encuentra una etiqueta Applet.
Para insertar el applet en una página web, se usa la siguiente estructura:



Ciclo de vida applet
Cuando un applet se carga en el appletviewer, comienza su ciclo de vida, que pasaría por las siguientes fases:

* Se crea una instancia de la clase que controla el applet.
* El applet se incializa.
* El applet comienza a ejecutarse.
* El applet empieza a recibir llamadas. Primero recibe una llamada init (inicializar), seguida de un mensaje start (empezar) y paint (pintar). Estas llamadas pueden ser recibidas asíncronamente.

lunes, 18 de mayo de 2009

Prueba MRU MRUV


public class Tabajo_clase extends javax.swing.JApplet {

/** Initializes the applet Tabajo_clase */
public void init() {
try {
java.awt.EventQueue.invokeAndWait(new Runnable() {
public void run() {
initComponents();
}
});
} catch (Exception ex) {
ex.printStackTrace();
}
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
Matriz Vo = new Matriz(1,3);
double aux = Double.parseDouble(jTextField8.getText());
Vo.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField1.getText());
Vo.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField10.getText());
Vo.matriz[0][2]= aux;

double t = Double.parseDouble(jTextField2.getText());

Matriz Xo = new Matriz(1,3);
aux = Double.parseDouble(jTextField9.getText());
Xo.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField3.getText());
Xo.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField11.getText());
Xo.matriz[0][2]= aux;

jTextArea1.setText(Xo.suma(Vo.multiplicaEscalar(t)).imprimir());
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
Matriz Vo = new Matriz(1,3);
double aux = Double.parseDouble(jTextField4.getText());
Vo.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField12.getText());
Vo.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField13.getText());
Vo.matriz[0][2]= aux;

double t = Double.parseDouble(jTextField5.getText());

Matriz a = new Matriz(1,3);
aux = Double.parseDouble(jTextField7.getText());
a.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField16.getText());
a.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField17.getText());
a.matriz[0][2]= aux;

Matriz Xo = new Matriz(1,3);
aux = Double.parseDouble(jTextField6.getText());
Xo.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField14.getText());
Xo.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField15.getText());
Xo.matriz[0][2]= aux;

jTextArea3.setText(Xo.suma(Vo.multiplicaEscalar(t)).suma(a.multiplicaEscalar(t*t).multiplicaEscalar(0.5)).imprimir());
}

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
Matriz Vo = new Matriz(1,3);
double aux = Double.parseDouble(jTextField4.getText());
Vo.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField12.getText());
Vo.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField13.getText());
Vo.matriz[0][2]= aux;

double t = Double.parseDouble(jTextField5.getText());

Matriz a = new Matriz(1,3);
aux = Double.parseDouble(jTextField7.getText());
a.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField16.getText());
a.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField17.getText());
a.matriz[0][2]= aux;

Matriz Xo = new Matriz(1,3);
aux = Double.parseDouble(jTextField6.getText());
Xo.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField14.getText());
Xo.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField15.getText());
Xo.matriz[0][2]= aux;

jTextArea2.setText(Vo.suma(a.multiplicaEscalar(t)).imprimir());
}

private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
Matriz Vo = new Matriz(1,3);
double aux = Double.parseDouble(jTextField8.getText());
Vo.matriz[0][0]= aux;
aux= Double.parseDouble(jTextField1.getText());
Vo.matriz[0][1]= aux;
aux= Double.parseDouble(jTextField10.getText());
Vo.matriz[0][2]= aux;

double x=1;
jTextArea4.setText(Vo.multiplicaEscalar(x).imprimir());
}
}

domingo, 17 de mayo de 2009

APPLET

Un applet es un componente de una aplicación que se ejecuta en el contexto de otro programa, por ejemplo un navegador web. El applet debe ejecutarse en un contenedor, que lo proporciona un programa anfitrión, mediante un plugin, o en aplicaciones como teléfonos móviles que soportan el modelo de programación por applets.

A diferencia de un programa, un applet no puede ejecutarse de manera independiente, ofrece información gráfica y a veces interactúa con el usuario, típicamente carece de sesión y tiene privilegios de seguridad restringidos. Un applet normalmente lleva a cabo una función muy específica que carece de uso independiente. El término fue introducido en AppleScript en 1993.

**** Ejemplos comunes de applets son las Java applets y las animaciones Flash. Otro ejemplo es el Windows Media Player utilizado para desplegar archivos de video incrustados en los navegadores como el Internet Explorer. Otros plugins permiten mostrar modelos 3D que funcionan con una applet.

Para crear un applet necesitamos escribir una clave de la clase Applet del paquete java.applet.*;

import java.applet.*;
public class MiApplet extends Applet
{
//Cuerpo del ''applet''.
}

Una vez creada la clase que compone el applet, escribimos el resto del código y después lo compilamos, obteniendo el fichero MiApplet.class. Para poder crear el applet se necesita compilar el código Java en un intérprete.

public class MiApplet extends Applet implements Runnable
{
private Thread hilo = null;
private Font fuente;
private String horaActual = "00:00:00";

public void init()
{
fuente = new Font("Verdana", Font.BOLD, 24);
}
public void start()
{
if (hilo == null)
{
hilo = new Thread(this, "Reloj");
hilo.start();
}
}
public void run()
{
Thread hiloActual = Thread.currentThread();
while (hilo == hiloActual)
{
//obtener la hora actual
Calendar cal = Calendar.getInstance();
Date hora = cal.getTime();
DateFormat df = DateFormat.getTimeInstance();
horaActual = df.format(hora);
repaint();
try
{
Thread.sleep(1000);
}
catch (InterruptedException e){}
}
}
public void paint(Graphics g)
{
//Dibujar un rectangulo alrededor del contenedor
g.draw3DRect(1, 1, getSize().width-3, getSize().height-3, false);
//Establecer la Fuente
g.setFont(fuente);
//mostrar la Hora
g.drawString(horaActual,14,40);
}
public void stop()
{
hilo = null;
}
}

martes, 12 de mayo de 2009

Librería Swing, Awt y operaciones con vectores

SWING
Swing es una biblioteca gráfica para Java. Incluye widgets para interfaz gráfica de usuario tales como cajas de texto, botones, desplegables y tablas.

Ventajas
* El diseño en Java puro posee menos limitaciones de plataforma.
* El desarrollo de componentes Swing es más activo.
* Los componentes de Swing soportan más características.

Arquitectura
Es una plataforma independiente, Model-View-Controller Gui framework para Java. Sigue un simple modelo de programación por hilos, y posee las siguientes características principales:

* Independencia de plataforma.
* Extensibilidad: es una arquitectura altamente particionada: los usuarios pueden proveer sus propias implementaciones modificadas para sobrescribir las implementaciones por defecto. Se puede extender clases existentes proveyendo alternativas de implementación para elementos esenciales.
* Customizable: dado el modelo de representación programático del framework de swing, el control permite representar diferentes 'look and feel' (desde MacOS look and feel hasta Windows XP look and feel). Más allá, los usuarios pueden proveer su propia implementación look and feel, que permitirá cambios uniformes en el look and feel existente en las aplicaciones Swing sin efectuar ningún cambio al código de aplicación.

AWT
AWT significa Abstract Window Toolkit. Permite hacer interfaces gráficas mediante artefactos de interacción con el usuario, como botones, menús, texto, botones para selección, barras de deslizamiento, ventanas de diálogo, selectores de archivos, etc. Y por supuesto despliegue gráfico general.

Caracteristicas
*Un widget es un elemento gráfico con el que el usuario puede interactuar.
*Ocupa una porción rectangular en una ventana.
*Existen diversos tipos: botones, áreas de texto, etiquetas, etc.
*El kit AWT implementa los widgets más usuales. Para usarlos es necesario importar las clases del paquete java.awt:

Construcción de una ventana de interacción
* Construcción del Frame:
Frame frame= new Frame("Titulo de la ventana");
* Construcción de widgets básicos de interacción:
Botón: Button boton= new Button("nombre del boton");
Etiqueta: Label etiq= new Label("nombre", Label.CENTER);
Area de texto: TextArea area= new TextArea(5, 20);
Campo de texto: TextField texto= new TextField(15);
Botón on/off: Checkbox check= new Checkbox("nombre");


OPERACIONES
package aplicacion;
public class Mivisual extends javax.swing.JFrame {
String aux ="";

public Mivisual() {
initComponents();
}
private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt){
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
double x1= Double.parseDouble(jTextField1.getText());
double y1= Double.parseDouble(jTextField2.getText());
double z1= Double.parseDouble(jTextField3.getText());
double x2= Double.parseDouble(jTextField4.getText());
double y2= Double.parseDouble(jTextField5.getText());
double z2= Double.parseDouble(jTextField6.getText());
Matriz v1 = new Matriz(1,3);
Matriz v2 = new Matriz(1,3);
v1.matriz[0][0] = x1; v1.matriz[0][1] = y1; v1.matriz[0][2] = z1;
v2.matriz[0][0] = x2; v2.matriz[0][1] = y2; v2.matriz[0][2] = z2;
aux += (v1.suma(v2)).imprimir();
jTextArea1.setText(aux);
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
double x1= Double.parseDouble(jTextField1.getText());
double y1= Double.parseDouble(jTextField2.getText());
double z1= Double.parseDouble(jTextField3.getText());
double x2= Double.parseDouble(jTextField4.getText());
double y2= Double.parseDouble(jTextField5.getText());
double z2= Double.parseDouble(jTextField6.getText());
Matriz v1 = new Matriz(1,3);
Matriz v2 = new Matriz(1,3);
v1.matriz[0][0] = x1; v1.matriz[0][1] = y1; v1.matriz[0][2] = z1;
v2.matriz[0][0] = x2; v2.matriz[0][1] = y2; v2.matriz[0][2] = z2;
aux += (v1.resta(v2)).imprimir();
jTextArea1.setText(aux);
}

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {
double x1= Double.parseDouble(jTextField1.getText());
double y1= Double.parseDouble(jTextField2.getText());
double z1= Double.parseDouble(jTextField3.getText());
double x2= Double.parseDouble(jTextField4.getText());
double y2= Double.parseDouble(jTextField5.getText());
double z2= Double.parseDouble(jTextField6.getText());
Matriz v1 = new Matriz(1,3);
Matriz v2 = new Matriz(1,3);
v1.matriz[0][0] = x1; v1.matriz[0][1] = y1; v1.matriz[0][2] = z1;
v2.matriz[0][0] = x2; v2.matriz[0][1] = y2; v2.matriz[0][2] = z2;
for(int i=0;i<1;i++){
for(int j=0;j<1;j++){
result.matriz[0][0]=result.matriz[0][0]+(v1.matriz[i][j]*v1.matriz[i][j]);
}
}
escalar1.matriz=result.matriz;
result.matriz[0][0]=0;
for(int i=0;i<1;i++){
for(int j=0;j<3;j++){
result.matriz[0][0]=result.matriz[0][0]+(v2.matriz[i][j]*v2.matriz[i][j]);
}
}
aux=(escalar1.suma(result)).imprimir();
jTextArea1.setText(aux);
}

private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {
double x1= Double.parseDouble(jTextField1.getText());
double y1= Double.parseDouble(jTextField2.getText());
double z1= Double.parseDouble(jTextField3.getText());
double x2= Double.parseDouble(jTextField4.getText());
double y2= Double.parseDouble(jTextField5.getText());
double z2= Double.parseDouble(jTextField6.getText());
Matriz v1 = new Matriz(1,3);
Matriz v2 = new Matriz(1,3);
v1.matriz[0][0] = x1; v1.matriz[0][1] = y1; v1.matriz[0][2] = z1;
v2.matriz[0][0] = x2; v2.matriz[0][1] = y2; v2.matriz[0][2] = z2;
aux += ((v1.multiplica(v2)).imprimir());
jTextArea1.setText(aux);
}

private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) {
double x1= Double.parseDouble(jTextField1.getText());
double y1= Double.parseDouble(jTextField2.getText());
double z1= Double.parseDouble(jTextField3.getText());
double x2= Double.parseDouble(jTextField4.getText());
double y2= Double.parseDouble(jTextField5.getText());
double z2= Double.parseDouble(jTextField6.getText());
Matriz v1 = new Matriz(1,3);
Matriz v2 = new Matriz(1,3);
Matriz result=new Matriz(1,1);
Matriz escalar1=new Matriz(1,3);
Matriz escalar2=new Matriz(1,3);
v1.matriz[0][0] = x1; v1.matriz[0][1]= y1; v1.matriz[0][2]=z1;
v2.matriz[0][0] = x2; v2.matriz[0][1]= y2; v2.matriz[0][2]=z2;
aux += "Unitario del vector 1 es: \n";
for(int i=0;i<1;i++){
for(int j=0;j<3;j++){
result.matriz[0][0]=result.matriz[0][0]+(v1.matriz[i][j]*v1.matriz[i][j]);
}
}
for(int i=0;i<1;i++){
for(int j=0;j<3;j++){
escalar1.matriz[i][j]=(v1.matriz[i][j])/(result.matriz[0][0]);
}
}
aux+=(escalar1.imprimir()+"\n");
aux += "Unitario del vector 2 es: \n";
result.matriz[0][0]=0;
for(int i=0;i<1;i++){
for(int j=0;j<3;j++){
result.matriz[0][0]=result.matriz[0][0]+(v1.matriz[i][j]*v1.matriz[i][j]);
}
}
for(int i=0;i<1;i++){
for(int j=0;j<3;j++){
escalar2.matriz[i][j]=(v2.matriz[i][j])/(result.matriz[0][0]);
}
}
aux+=(escalar2.imprimir()+"\n");
aux+="El total de los unitarios es \n";
aux+=(escalar1.suma(escalar2)).imprimir()+"\n";
jTextArea1.setText(aux);
}

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Mivisual().setVisible(true);
}
});
}

domingo, 10 de mayo de 2009

Herencia Vectorial

package herencia;
public class Matriz {
int numeroFilas;
int numeroColumnas;
double [][] matriz;

public Matriz(){}
public Matriz(int nF, int nC){
numeroFilas=nF;
numeroColumnas=nC;
matriz= new double[numeroFilas][numeroColumnas];

for(int i=0; i< numeroFilas; i++)
for(int j=0; j< numeroColumnas; j++)
matriz[i][j]=0;
}

public String imprimir(){
String aux = "";
for(int i=0; i for(int j=0; j aux= aux + matriz[i][j] + " ";
}
aux = aux + "\n";
}
return aux;
}

public String imprimir2(){
String aux ="";
aux=aux+"y1="+ matriz[0][0];
aux=aux+"\n";
aux=aux+"y2="+matriz[1][0];
return aux;
}

public Matriz suma(Matriz B){
if ((this.numeroFilas == B.numeroFilas)&(this.numeroColumnas==B.numeroColumnas)){
Matriz r = new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
for(int i = 0; i < this.numeroFilas; i++)
for(j = 0; j r.matriz[i][j]=this.matriz[i][j]+B.matriz[i][j];
return r;
}
else{
Matriz r = new Matriz (1,1);
System .out.println("No se pueden sumar las matrices");
return r;
}
}

public Matriz resta(Matriz B){
if ((this.numeroFilas == B.numeroFilas)&(this.numeroColumnas==B.numeroColumnas)){
Matriz r = new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
for(int i = 0; i < this.numeroFilas; i++)
for(j = 0; j r.matriz[i][j]=this.matriz[i][j]-B.matriz[i][j];
return r;
}
else{
Matriz r = new Matriz (1,1);
System .out.println("No se pueden restar las matrices");
return r;
}
}

public Matriz multiplica(Matriz B){
if(this.numeroFilas==B.numeroColumnas){
Matriz r = new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
int k;
for(int i = 0; i < this.numeroFilas; i++)
for(j = 0; j for(k=0; k r.matriz[i][j]+=this.matriz[i][k]*B.matriz[k][j];
return r;
}
else{
Matriz r = new Matriz (1,1);
System .out.println("No se pueden multiplicar las matrices");
return r;
}
}

public Matriz clonar(){
Matriz r= new Matriz(this.numeroFilas, this.numeroColumnas);
int j;
for(int i = 0; i < this.numeroFilas; i++)
for(j = 0; j r.matriz[i][j]=this.matriz[i][j];
return r;
}
public Matriz transpueta(){
Matriz r = new Matriz(this.numeroColumnas,this.numeroFilas);
int j;
for (int i = 0; i < this.numeroFilas; i++)
for(j = 0; j < this.numeroColumnas;j++)
r.matriz[j][i] = this.matriz[i][j];
return r;
}

public Matriz inversa(){
Matriz result=new Matriz(this.numeroFilas,this.numeroColumnas);
double tmp;//variable temporal
Matriz I=new Matriz(this.numeroFilas,this.numeroColumnas*2);
for(int i = 0; i for(int j = 0; j I.matriz[i][j]=0.0;

for(int i = 0; i for(int j = 0; j I.matriz[i][j]=this.matriz[i][j];
if (i==j)
I.matriz[i][j+this.numeroFilas]=1.0;
}
}
for(int i=0; i<(this.numeroFilas); i++){
tmp=I.matriz[i][i];
for(int j=0;j<(this.numeroColumnas*2);j++)
I.matriz[i][j]/=tmp;
for(int k=0;k if(k!=i){
tmp=I.matriz[k][i];
for(int j=0;j<(this.numeroColumnas*2);j++)
I.matriz[k][j]-=tmp*I.matriz[i][j];
}
}
}
for(int i = 0; i < this.numeroFilas; i++)
for(int j = 0; j result.matriz[i][j]=I.matriz[i][j+this.numeroColumnas];
return result;
}
public Matriz multiplicaEscalar(double a){
Matriz r= new Matriz(this.numeroFilas, this.numeroColumnas);
for(int i = 0; i < this.numeroFilas; i++)
for(int j = 0; j r.matriz[i][j]= this.matriz[i][j]*a;
return r;
}
}

package herencia;
public class Vector extends Matriz{
public Vector(){
}
public Vector(int numElementos){
numeroFilas = 1;
numeroColumnas = numElementos;
matriz = new double[numeroFilas][numeroColumnas];
}

public Vector(int nF, int nC){
super(nF,nC);
}

public double productoEscalar(Vector x){
double resultado =0;
resultado=this.multiplica(x.transpueta()).matriz[0][0];
return resultado;
}

public static void main(String[] args){
Vector v = new Vector(3,3);
v.matriz[0][0]= 1;
v.matriz[0][1]= 0;
v.matriz[0][2]= 1;
System.out.println(v.imprimir());

Vector v1 = new Vector(3,3);
v1.matriz[0][0]= 1;
v1.matriz[0][1]= 2;
v1.matriz[0][2]= 3;
System.out.println(v1.imprimir());
System.out.println((v.suma(v1)).imprimir());
System.out.println("El producto vectorial");
System.out.println((v1.multiplica(v)).imprimir());
}
}

domingo, 19 de abril de 2009

MRU y MRUV vectorial

MRU
public class Particula {
private Matriz posicionInicial;
private Matriz velocidadInicial;
private Matriz aceleracion;

public Particula(){}
public Particula(Matriz Xo, Matriz Vo, Matriz a){
posicionInicial = Xo;
velocidadInicial = Vo;
aceleracion = a;
}

public Matriz getPosicionInicial(){
return posicionInicial;
}
public void setPosicionInicial(Matriz Xo){
posicionInicial = Xo;
}
public Matriz getAceleracion(){
return aceleracion;
}
public void setAceleracion(Matriz a){
aceleracion = a;
}
public Matriz getVelocidadInicial(){
return velocidadInicial;
}
public void setVelocidadInicial(Matriz Vo){
velocidadInicial = Vo;
}
}
package encapsulamientoii;
public class Matriz {
int numeroFilas;
int numeroColumnas;
double [][] matriz;

public Matriz(){}
public Matriz(int nF, int nC){
numeroFilas=nF;
numeroColumnas=nC;
matriz= new double[numeroFilas][numeroColumnas];

for(int i=0; i< numeroFilas; i++)
for(int j=0; j< numeroColumnas; j++)
matriz[i][j]=0;
}

public String imprimir(){
String aux = "";
for(int i=0; i for(int j=0; j aux= aux + matriz[i][j] + " ";
}
aux = aux + "\n";
}
return aux;
}

public String imprimir2(){
String aux ="";
aux=aux+"y1="+ matriz[0][0];
aux=aux+"\n";
aux=aux+"y2="+matriz[1][0];
return aux;
}

public Matriz suma(Matriz B){
if ((this.numeroFilas == B.numeroFilas)&(this.numeroColumnas==B.numeroColumnas)){
Matriz r = new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
for(int i = 0; i < this.numeroFilas; i++)
for(j = 0; j r.matriz[i][j]=this.matriz[i][j]+B.matriz[i][j];
return r;
}
else{
Matriz r = new Matriz (1,1);
System .out.println("No se pueden sumar las matrices");
return r;
}
}
public Matriz multiplicaEscalar(double a){
Matriz r= new Matriz(this.numeroFilas, this.numeroColumnas);
for(int i = 0; i < this.numeroFilas; i++)
for(int j = 0; j r.matriz[i][j]= this.matriz[i][j]*a;
return r;
}
}
package encapsulamientoii;
public class MovRecUNi {
public Particula particula;

public MovRecUNi(){}
public MovRecUNi(Matriz x0, Matriz v0, Matriz a){
particula = new Particula();
particula.setPosicionInicial(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}

public Matriz calcularPosicion(double t){
Matriz posicion;
Matriz x0, v0, a;
x0 = this.particula.getPosicionInicial();
posicion = new Matriz(x0.numeroFilas,x0.numeroColumnas);
v0 = this.particula.getVelocidadInicial();
a = this.particula.getAceleracion();
posicion = x0.suma(v0.multiplicaEscalar(t));
return posicion;
}

public Matriz calculoVelocidad(double t){
Matriz velocidad = particula.getVelocidadInicial();
return velocidad;
}

public Matriz calculoAceleracion(double t){
Matriz aceleracion = new Matriz(1,this.particula.getPosicionInicial().numeroColumnas);
for(int i = 0; i < aceleracion.numeroFilas; i++)
for(int j = 0; j < aceleracion.numeroColumnas; j++)
aceleracion.matriz[i][j] = 0;
return aceleracion;
}

public static void main(String args[]){
Matriz x0 = new Matriz(1,3);
x0.matriz[0][0]=5; x0.matriz[0][1]=0; x0.matriz[0][2]=-5;
Matriz v0 = new Matriz(1,3);
v0.matriz[0][0]=2; v0.matriz[0][1]=0; v0.matriz[0][2]=0;
Matriz a = new Matriz(1,3);
a.matriz[0][0]=0; a.matriz[0][1]=0; a.matriz[0][2]=0;
MovRecUNi m = new MovRecUNi(x0,v0,a);

Matriz x;
x = m.calcularPosicion(2);
Matriz v;
v = m.calculoVelocidad(2);
Matriz ac;
ac = m.calculoAceleracion(2);

System.out.println("la posicion inicial\n"+x0.imprimir());
System.out.println("la posicion final\n"+x.imprimir());
System.out.println("la velocidad inicial\n"+v0.imprimir());
System.out.println("la velocidad final\n"+v0.imprimir());
}
}

MRUV
public class Particula {
private Matriz posicionInicial;
private Matriz velocidadInicial;
private Matriz aceleracion;

public Particula(){}
public Particula(Matriz Xo, Matriz Vo, Matriz a){
posicionInicial = Xo;
velocidadInicial = Vo;
aceleracion = a;
}

public Matriz getPosicionInicial(){
return posicionInicial;
}
public void setPosicionInicial(Matriz Xo){
posicionInicial = Xo;
}
public Matriz getAceleracion(){
return aceleracion;
}
public void setAceleracion(Matriz a){
aceleracion = a;
}
public Matriz getVelocidadInicial(){
return velocidadInicial;
}
public void setVelocidadInicial(Matriz Vo){
velocidadInicial = Vo;
}
}
package encapsulamientoii;
public class Matriz {
int numeroFilas;
int numeroColumnas;
double [][] matriz;

public Matriz(){}
public Matriz(int nF, int nC){
numeroFilas=nF;
numeroColumnas=nC;
matriz= new double[numeroFilas][numeroColumnas];

for(int i=0; i< numeroFilas; i++)
for(int j=0; j< numeroColumnas; j++)
matriz[i][j]=0;
}

public String imprimir(){
String aux = "";
for(int i=0; i for(int j=0; j aux= aux + matriz[i][j] + " ";
}
aux = aux + "\n";
}
return aux;
}

public String imprimir2(){
String aux ="";
aux=aux+"y1="+ matriz[0][0];
aux=aux+"\n";
aux=aux+"y2="+matriz[1][0];
return aux;
}

public Matriz suma(Matriz B){
if ((this.numeroFilas == B.numeroFilas)&(this.numeroColumnas==B.numeroColumnas)){
Matriz r = new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
for(int i = 0; i < this.numeroFilas; i++)
for(j = 0; j r.matriz[i][j]=this.matriz[i][j]+B.matriz[i][j];
return r;
}
else{
Matriz r = new Matriz (1,1);
System .out.println("No se pueden sumar las matrices");
return r;
}
}
public Matriz multiplicaEscalar(double a){
Matriz r= new Matriz(this.numeroFilas, this.numeroColumnas);
for(int i = 0; i < this.numeroFilas; i++)
for(int j = 0; j r.matriz[i][j]= this.matriz[i][j]*a;
return r;
}
}
package encapsulamientoii;
public class MRUVV {
public Particula particula;

public MRUVV(){}
public MRUVV(Matriz x0, Matriz v0, Matriz a){
particula = new Particula();
particula.setPosicionInicial(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}

public Matriz calcularPosicion(double t){
Matriz posicion;
Matriz x0, v0, a;
x0 = this.particula.getPosicionInicial();
posicion = new Matriz(x0.numeroFilas,x0.numeroColumnas);
v0 = this.particula.getVelocidadInicial();
a = this.particula.getAceleracion();
posicion = x0.suma(v0.multiplicaEscalar(t).suma(a.multiplicaEscalar(t*0.5*t)));
return posicion;
}

public Matriz calculoVelocidad(double t){
Matriz velocidad= particula.getVelocidadInicial();
Matriz x0, v0, a;
v0 = this.particula.getVelocidadInicial();
velocidad = new Matriz(v0.numeroFilas,v0.numeroColumnas);
x0 = this.particula.getPosicionInicial();
a = this.particula.getAceleracion();
velocidad = v0.suma(a.multiplicaEscalar(t));
return velocidad;
}

public Matriz calculoAceleracion(double t){
Matriz aceleracion = new Matriz(1,this.particula.getPosicionInicial().numeroColumnas);
for(int i = 0; i < aceleracion.numeroFilas; i++)
for(int j = 0; j < aceleracion.numeroColumnas; j++)
aceleracion.matriz[i][j] = 0;
return aceleracion;
}

public static void main(String args[]){
Matriz x0 = new Matriz(1,3);
x0.matriz[0][0]=4; x0.matriz[0][1]=0; x0.matriz[0][2]=-3;
Matriz v0 = new Matriz(1,3);
v0.matriz[0][0]=3; v0.matriz[0][1]=2; v0.matriz[0][2]=0;
Matriz a = new Matriz(1,3);
a.matriz[0][0]=3; a.matriz[0][1]=2; a.matriz[0][2]=2;
MRUVV m = new MRUVV(x0,v0,a);

Matriz x;
x = m.calcularPosicion(4);
Matriz v;
v = m.calculoVelocidad(4);
Matriz ac;
ac = m.calculoAceleracion(4);

System.out.println("la posicion inicial\n"+x0.imprimir());
System.out.println("la posicion final\n"+x.imprimir());
System.out.println("la velocidad inicial\n"+v0.imprimir());
System.out.println("la velocidad final\n"+v.imprimir());
System.out.println("la aceleracion inicial\n"+a.imprimir());
System.out.println("la aceleracion final\n"+a.imprimir());
}
}

martes, 14 de abril de 2009

MRU y MRUV

MRU
public class Particula {
private double posicionInicial;
private double velocidadInicial;
private double aceleracion;

public Particula(){}
public Particula(double Xo, double Vo, double a){
posicionInicial = Xo;
velocidadInicial = Vo;
aceleracion = a;
}

public double getPosicionInicial(){
return posicionInicial;
}

public void setPosicionInicial(double Xo){
posicionInicial = Xo;
}

public double getAceleracion(){
return aceleracion;
}

public void setAceleracion(double a){
aceleracion = a;
}

public double getVelocidadInicial(){
return velocidadInicial;
}

public void setVelocidadInicial(double Vo){
velocidadInicial = Vo;
}
}
public class MovRecUNi {
public Particula particula;

public MovRecUNi(){}
public MovRecUNi(double Xo, double Vo, double a){
particula.setPosicionInicial(Xo);
particula.setVelocidadInicial(Vo);
particula.setAceleracion(a);
}

public double calcularPosicion(double t){
double posicion;
posicion = particula.getPosicionInicial()+particula.getVelocidadInicial()*t;
return posicion;
}

public double calculoVelocidad(double t){
double velocidad = particula.getVelocidadInicial();
return velocidad;
}

public double calculoAceleracion(double t){
double aceleracion = 0;
return aceleracion;
}
}
public class Prueba {
public static void main(String args[]){
Particula p = new Particula(0.0,0.0,0);
p.setVelocidadInicial(4);
p.setPosicionInicial(2);
p.setAceleracion(0);
System.out.println("Velocidad inicial\n"+p.getVelocidadInicial());
System.out.println("Posicion inicial\n"+p.getPosicionInicial());
System.out.println("Aceleracion\n"+p.getAceleracion());
MovRecUNi m = new MovRecUNi();
m.particula=p;
System.out.println("Posicion a t = 20\n"+m.calcularPosicion(20));
System.out.println("Velocidad a t = 20\n"+m.calculoVelocidad(20));
System.out.println("Aceleracion a t = 20\n"+m.calculoAceleracion(20));
}
}

MRUV


public class Particula2 {
private double posicionInicial;
private double velocidadInicial;
private double aceleracion;

public Particula2(){}
public Particula2(double Xo, double Vo, double a){
posicionInicial = Xo;
velocidadInicial = Vo;
aceleracion = a;
}

public double getPosicionInicial(){
return posicionInicial;
}

public void setPosicionInicial(double Xo){
posicionInicial = Xo;
}

public double getAceleracion(){
return aceleracion;
}

public void setAceleracion(double a){
aceleracion = a;
}

public double getVelocidadInicial(){
return velocidadInicial;
}

public void setVelocidadInicial(double Vo){
velocidadInicial = Vo;
}
}
public class MRUV {
public Particula2 particula;

public MRUV(){}
public MRUV(double Xo, double Vo, double a){
particula.setPosicionInicial(Xo);
particula.setVelocidadInicial(Vo);
particula.setAceleracion(a);
}

public double calcularPosicion(double t){
double posicion;
posicion = particula.getPosicionInicial()+particula.getVelocidadInicial()*t+particula.getAceleracion()*(0.5*t*t);
return posicion;
}

public double calculoVelocidad(double t){
double velocidad = particula.getVelocidadInicial();
velocidad = particula.getVelocidadInicial()+particula.getAceleracion()*t;
return velocidad;
}

public double calculoAceleracion(double t){
double aceleracion = particula.getAceleracion();
return aceleracion;
}
}
public class Prueba2 {
public static void main(String args[]){
Particula2 p = new Particula2(0.0,0.0,0);
p.setVelocidadInicial(10);
p.setPosicionInicial(4);
p.setAceleracion(6);
MRUV m = new MRUV();
m.particula=p;
System.out.println("Posicion a t = 4\n"+m.calcularPosicion(4));
System.out.println("Velocidad a t = 4\n"+m.calculoVelocidad(4));
System.out.println("Aceleracion a t = 4\n"+m.calculoAceleracion(4));
}
}

lunes, 6 de abril de 2009

Evaluacion

1) Resolver

a) x1=-1; x2=2; x3=-3

b) x1=1; x2=0; x3=1; x4=0; x5=0;

2) Encontrar

a) a + b = | 4 2 4 |

b) a + b = | 0 4 4 |

c) a' * b =
| 4 -2 0 |
| 6 -3 0 |
| 8 -4 0 |

domingo, 5 de abril de 2009

Codigo Inversa y multiplicacion

public class Matriz {
int numfilas;
int numcolum;
double [][] matriz;

public Matriz (){}
public Matriz(int nF, int nC){
numfilas= nF;
numcolum= nC;
matriz= new double[numfilas][numcolum];
for(int i=0; i for(int j=0; j matriz[i][j]= 0;
}

public String imprimir(){
String aux = "";
for(int i=0; i for(int j=0; j aux = aux + matriz[i][j] +" ";
}
aux= aux +"\n";
}
return aux;
}

public Matriz multiplicacion(Matriz B){
Matriz r = new Matriz(this.numfilas,B.numcolum);
int j;
int k;
for(int i=0; i for(j=0; j for(k=0; k r.matriz[i][j] += this.matriz[i][k]*B.matriz[k][j];
return r;
}

public Matriz inversa(){
Matriz result=new Matriz(this.numfilas,this.numcolum);
double tmp;
Matriz I=new Matriz(this.numfilas,this.numcolum*2);
for(int i=0;i for(int j=0;j I.matriz[i][j]=0.0;
for(int i=0;i for(int j=0;j I.matriz[i][j]=this.matriz[i][j];
if (i==j)
I.matriz[i][j+this.numfilas]=1.0;
}
}
for(int i=0;i tmp=I.matriz[i][i];
for(int j=0;j<(this.numcolum*2);j++)
I.matriz[i][j]/=tmp;
for(int k=0;k if(k!=i){
tmp=I.matriz[k][i];
for(int j=0;j<(this.numcolum*2);j++)
I.matriz[k][j]-=tmp*I.matriz[i][j];
}
}
}
for(int i=0;i for(int j=0;j result.matriz[i][j]=I.matriz[i][j+this.numcolum];
return result;
}

public static void main(String args []){
Matriz m=new Matriz(2,2);
m.matriz[0][0]=1;
m.matriz[0][1]=1;
m.matriz[1][0]=-1;
m.matriz[1][1]=2;
System.out.println(m.imprimir());

Matriz b=new Matriz(2,2);
b.matriz[0][0]=1;
b.matriz[1][0]=0;
System.out.println(b.imprimir());

Matriz resultado;
resultado=m.inversa();
System.out.println(resultado.imprimir());

resultado=m.multiplicacion(b);
System.out.println(resultado.imprimir());

resultado=m.inversa().multiplicacion(b);
System.out.println(resultado.imprimir());
}
}

miércoles, 1 de abril de 2009

Inversa

public class Matriz {
int numfilas;
int numcolum;
double [][] matriz;

public Matriz (){}
public Matriz(int nF, int nC){
numfilas= nF;
numcolum= nC;
matriz= new double[numfilas][numcolum];
for(int i=0; i for(int j=0; j matriz[i][j]= 0;
}

public String imprimir(){
String aux = "";
for(int i=0; i for(int j=0; j aux = aux + matriz[i][j] +" ";
}
aux= aux +"\n";
}
return aux;
}

public Matriz multiplicacion(Matriz B){
Matriz r = new Matriz(this.numfilas,B.numcolum);
int j;
int k;
for(int i=0; i for(j=0; j for(k=0; k r.matriz[i][j] += this.matriz[i][k]*B.matriz[k][j];
return r;
}

public Matriz inversa(){
Matriz result=new Matriz(this.numfilas,this.numcolum);
double tmp;
Matriz I=new Matriz(this.numfilas,this.numcolum*2);
for(int i=0;i for(int j=0;j I.matriz[i][j]=0.0;
for(int i=0;i for(int j=0;j I.matriz[i][j]=this.matriz[i][j];
if (i==j)
I.matriz[i][j+this.numfilas]=1.0;
}
}
for(int i=0;i tmp=I.matriz[i][i];
for(int j=0;j<(this.numcolum*2);j++)
I.matriz[i][j]/=tmp;
for(int k=0;k if(k!=i){
tmp=I.matriz[k][i];
for(int j=0;j<(this.numcolum*2);j++)
I.matriz[k][j]-=tmp*I.matriz[i][j];
}
}
}
for(int i=0;i for(int j=0;j result.matriz[i][j]=I.matriz[i][j+this.numcolum];
return result;
}


public static void main(String args []){
Matriz m=new Matriz(2,2);
m.matriz[0][0]=1;
m.matriz[0][1]=-1;
m.matriz[1][0]=2;
m.matriz[1][1]=1;
System.out.println(m.imprimir());

Matriz b=new Matriz(2,2);
b.matriz[0][0]=3;
b.matriz[1][0]=-4;
System.out.println(b.imprimir());

Matriz resultado;
resultado=m.inversa();
System.out.println(resultado.imprimir());

resultado=m.multiplicacion(b);
System.out.println(resultado.imprimir());

resultado=m.inversa().multiplicacion(b);
System.out.println(resultado.imprimir());
}
}

domingo, 29 de marzo de 2009

Operaciones con matrices en java

public class Matriz {
int numfilas;
int numcolum;
double [][] matriz;

public Matriz (){}
public Matriz(int nF, int nC){
numfilas= nF;
numcolum= nC;
matriz= new double[numfilas][numcolum];
for(int i=0;i for(int j=0;j matriz[i][j]= 0;
}

public String imprimir(){
String aux = "";

for(int i=0; i for(int j=0; j aux = aux + matriz[i][j] +" ";
}
aux= aux +"\n";
}
return aux;
}

public Matriz suma(Matriz B){
if ((this.numfilas == B.numfilas)&(this.numcolum == B.numcolum)){
Matriz r = new Matriz(this.numfilas,this.numcolum);
int j;
for(int i=0; i for(j=0; j r.matriz[i][j]= this.matriz[i][j]+B.matriz[i][j];
return r;
}
else{
Matriz r = new Matriz (1,1);
System.out.println("No se pueden sumar las matrices");
return r;
}
}
public Matriz resta(Matriz B){
if ((this.numfilas == B.numfilas)&(this.numcolum == B.numcolum)){
Matriz r = new Matriz(this.numfilas,this.numcolum);
int j;
for(int i=0; i for(j=0; j r.matriz[i][j]= this.matriz[i][j]-B.matriz[i][j];
return r;
}
else{
Matriz r = new Matriz (1,1);
System.out.println("No se pueden restar las matrices");
return r;
}
}

public Matriz multiplicacion(Matriz B){
Matriz r = new Matriz(this.numfilas,B.numcolum);
int j;
int k;
for(int i=0; i for(j=0; j for(k=0; k r.matriz[i][j] += this.matriz[i][k]*B.matriz[k][j];
return r;
}

public Matriz traspuesta(){
Matriz r = new Matriz(this.numcolum,this.numfilas);
int j;
for(int i=0; i for(j=0; j r.matriz[i][j]= this.matriz[j][i];
return r;
}

public Matriz inversa(){
Matriz result=new Matriz(this.numfilas,this.numcolum);
double tmp;
Matriz I=new Matriz(this.numfilas,this.numcolum*2);
for(int i=0;i for(int j=0;j I.matriz[i][j]=0.0;
for(int i=0;i for(int j=0;j I.matriz[i][j]=this.matriz[i][j];
if (i==j)
I.matriz[i][j+this.numfilas]=1.0;
}
}
for(int i=0;i tmp=I.matriz[i][i];
for(int j=0;j<(this.numcolum*2);j++)
I.matriz[i][j]/=tmp;
for(int k=0;k if(k!=i){
tmp=I.matriz[k][i];
for(int j=0;j<(this.numcolum*2);j++)
I.matriz[k][j]-=tmp*I.matriz[i][j];
}
}
}
for(int i=0;i for(int j=0;j result.matriz[i][j]=I.matriz[i][j+this.numcolum];
return result;
}

public static void main(String args []){
Matriz m = new Matriz(3, 3);
m.matriz[0][0]= 1;
m.matriz[1][1]= 3;
m.matriz[2][2]= 5;
System.out.println(m.imprimir());

Matriz b = new Matriz(3, 3);
b.matriz[0][0]= 1;
b.matriz[0][1]= 2;
b.matriz[0][2]= 3;
b.matriz[1][1]= 4;
b.matriz[1][2]= 5;
b.matriz[2][2]= 6;
System.out.println(b.imprimir());

Matriz resultado;
resultado = m.suma(b);
System.out.println(resultado.imprimir());

resultado = m.resta(b);
System.out.println(resultado.imprimir());

resultado = m.multiplicacion(b);
System.out.println(resultado.imprimir());

resultado = b.traspuesta();
System.out.println(resultado.imprimir());

resultado = m.traspuesta();
System.out.println(resultado.imprimir());

resultado = m.inversa();
System.out.println(resultado.imprimir());

resultado = b.inversa();
System.out.println(resultado.imprimir());
}
}

domingo, 22 de marzo de 2009

Programacion orientada a objetos

Es un método de programación en el que un programa se contempla como un conjunto de objetos limitados que, a su vez, son colecciones independientes de estructuras de datos y rutinas que interactúan con otros objetos, o que dan acceso para modificar el contenido de un dato o propiedad del propio objeto. También se identifica con las siglas POO y OOP (del inglés Object Oriented Programming).
El concepto clave en la programación orientada a objetos es la denominada clase (de objetos). Una clase define las estructuras de datos y rutinas de un objeto.

[public] class Classname {
//definicion de variables y metodos
. . .
}

A su vez, un objeto es una instancia de una clase, que se puede usar como una variable en un programa; es decir, la creación de una instancia de una clase se corresponde con la declaración de una variable en la programación tradicional, pero refiriéndose a objetos.

Classname unObjeto;
Classname otroObjeto;

En cuanto a la funcionalidad y la metodología interna, la programación orientada a objetos se fundamenta en la metodos, la herencia y atributos. La encapsulación significa que en una clase se declaran los tipos de datos y el medio de manipularlos (sus métodos). La herencia supone crear clases derivadas de otras existentes, que heredan sus tipos y métodos y pueden contener otros nuevos. Si una nueva clase hereda propiedades de más de una antecesora, se denomina herencia múltiple; no todos los lenguajes orientados a objetos lo permiten. El estado está compuesto de datos, será uno o varios atributos a los que se habrán asignado unos valores concretos.

public static void main(String[] args) {
int [] a;
int [] b;
int [] c;
int x;
a = new int [5];
b = new int [5];
c = new int [5];

//construimos la matriz a
a[0]=1; a[1]=1; a[2]=9; a[3]=9; a[4]=2;

//construimos la matriz b
b[0]=3; b[1]=2; b[2]=4; b[3]=2; b[4]=2;

//suma
for(int i=0; i<5; i++)
c[i]= a[i]+b[i];

for(int i=2;i>0;i--)
{
c[i]=a[i]+b[i]+(a[i+1]%b[i+1]);
x =c[i];
if(x>=10)
c[i]=x-10;
}
c[0]=a[0]+b[0];

for(int i=0; i<5; i++){
System.out.print(c[i]+ " ");
}
System.out.println();
}

lunes, 16 de marzo de 2009

Arreglos en Java

"Arreglos en Java"

Los arreglos en Java son objetos, demostrando el compromiso de Java con la orientación a objetos. En esta sección se encuentran diversos ejemplos de arreglos unidimensionales y multidimensionales, y se exponen las manipulaciones más comunes de estos. También el proceso de pasar arreglos a métodos y las técnicas elementales para ordenar y realizar búsquedas, junto con la presentación de la búsqueda binaria como una mejora sobre la búsqueda lineal.

Un arreglo se declara de la siguiente forma:
[] ;
O sea, para declarar, por ejemplo, un arreglo de números enteros utilizaremos la siguiente sentencia:
int[] arrInt;
Es importante notar que el arreglo aún no ha sido creado, sino meramente declarado. Para crear el arreglo (reservar su memoria e inicializarlo) deberemos recurrir al operador new:
arrInt = new int[10];
Este comportamiento debe comprenderse de esta forma: en Java todo es un objeto, y los objetos deben ser creados mediante el operador new. El caso de los arreglos no es diferente, el tipo de datos del arreglo (int[] en este caso) es una clase y cada una de sus instancias debe ser creada explícitamente, el tamaño puede pensarse como un parámetro al constructor de la clase.
A partir de este momento podemos utilizar arrInt como un arreglo de cualquier otro lenguaje
Una de las características que hacen de Java un entorno de programación seguro, y que se relaciona con el manejo de los arreglos es que el lenguaje no permite la indexación de arreglos fuera de rango, o sea, una asignación de este tipo generará una excepción:
ArrInt[25] = 1;
Otra forma de declararlos es la siguiente:
UNIDIMENSIONALES:
tipo nombre_array[]=new tipo[nº];
tipo nombre_array[]={valores};
BIDIMENSIONALES:
tipo nombre_array[][]=new tipo[nº][nº];
tipo nombre_array[][]={valores};
Para utilizar un arreglo en Java:
-Declare una variable para que contenga el arreglo
-Cree un nuevo arreglo de objeto y as�gnelo a la variable de arreglo
-Almacene informaci�n en ese arreglo
-Realice operaciones de almacenamiento y recuperaci�n con los elementos del arreglo
Ejemplo:
public class ArrayPlay{
int[] intarray = new int[0];
public static void main(String[] args){
ArrayPlay arrayplay = new ArrayPlay();
arrayplay.play();
}
Fuente de consulta:

domingo, 15 de marzo de 2009

Ejercicios con dos vectores en java

public static void main(String[] args) {
int [] a;
int [] b;
double [] c;
a = new int [3];
b = new int [3];
c = new double [3];
double productocruz;
double magnitud1, magnitud2;
double angulo, angulo1, angulo2;
int suma;
int resta;
double productoescalar;
a[0]=1; a[1]=2; a[2]=3;
b[0]=2; b[1]=3; b[2]=4;

//suma
for(int i=0; i<3 ; i++)
c[i] = a[i] +b[i];

for(int i=0; i<3; i++)
System.out.print("la suma de los vectores es: " + c[i] + "\n");

//resta
for(int i=0; i<3 ; i++)
c[i] = a[i] -b[i];

for(int i=0; i<3; i++)
System.out.print("La resta de los vectores: " + c[i] + "\n");

//producto escalar
productoescalar = 0;
for(int i=0; i<3; i++)
productoescalar += a[i] *b[i];
System.out.println("El producto escalar es:: " + productoescalar);

//magnitud
magnitud1 = Math.sqrt(Math.pow(a[0],2)+Math.pow(a[1],2)+Math.pow(a[2],2));
magnitud2 = Math.sqrt(Math.pow(b[0],2)+Math.pow(b[1],2)+Math.pow(b[2],2));
System.out.println("La magnitud de a es: " + magnitud1);
System.out.println("La magnitud de b es: " + magnitud2);

//vector unitario
for(int i=0; i<3; i++)
c[i] = a[i]/productoescalar;
for(int i=0; i<3; i++)
System.out.println("El unitario de a es: " + c[i]);
for(int i=0; i<3; i++)
c[i] = b[i]/productoescalar;
for (int i=0; i<3; i++)
System.out.println("El unitario de b es: " + c[i]);

//angulo
angulo1 = Math.sqrt(Math.pow(a[0],2)+Math.pow(a[1],2)+Math.pow(a[2],2));
angulo2 = Math.sqrt(Math.pow(b[0],2)+Math.pow(b[1],2)+Math.pow(b[2],2));
angulo = Math.acos(productoescalar/(angulo1*angulo2));
System.out.println("El angulo es: " + angulo);

//producto cruz
productocruz = (((a[1] *b[2]) - (a[2] *b[1])) - ((a[0] *b[2]) - (b[0] *a[2])) + ((a[0] *b[1]) - (b[0] *a[1])));
System.out.println("El valor cruz es: " +productocruz);
}
}

RESOLUCION
run:
la suma de los vectores es: 3.0
la suma de los vectores es: 5.0
la suma de los vectores es: 7.0
La resta de los vectores: -1.0
La resta de los vectores: -1.0
La resta de los vectores: -1.0
El producto escalar es:: 20.0
La magnitud de a es: 3.7416573867739413
La magnitud de b es: 5.385164807134504
El unitario de a es: 0.05
El unitario de a es: 0.1
El unitario de a es: 0.15
El unitario de b es: 0.1
El unitario de b es: 0.15
El unitario de b es: 0.2
El angulo es: 0.12186756768575456
El valor cruz es: 0.0
BUILD SUCCESSFUL (total time: 2 seconds)

martes, 10 de marzo de 2009

Tarea 1

¿Qué es Java?
Lenguaje de programación orientado a objetos desarrollado por la empresa Sun Microsystems en 1995 y que se ha extendido ampliamente en World Wide Web. Es un lenguaje de alto nivel y propósito general similar a C++, con marcadas características de seguridad y transportabilidad. Este lenguaje define una máquina virtual independiente de la plataforma donde se ejecuta, que procesa programas, llamados Applets, descargados desde el servidor Web. Además, debido al modo de ejecución de los Applets, este lenguaje es muy seguro frente a la presencia y ataque de virus informáticos.

A principios de la decada de los noventa se lo comenzo a desarrollar. Las aplicaciones Java
están típicamente compiladas en un bytecode. En el tiempo de ejecucion, el bytecode es normalmente interpretado o compilado a código nativo para la ejecución, aunque la ejecución directa por hardware del bytecode por un procesador Java también se lo puede realizar.

¿Qué es JDK?
Es un software que provee herramientas de desarrollo para la creación de programas en java . Puede instalarse en una computadora local o en una unidad de red.

En la unidad de red se puede tener la aplicación distribuida en varias computadoras y trabajar como una sola aplicación.

La estructura de directorios del JDK/J2SE es la siguiente:
JDK 1.4.2
____________________________

bin lib jre
________ __________
java* tools.jar
javac* dt.jar bin lib
javap* ________ ______ _________ ________ ______
javah* java*
javadoc* rt.jar ext security i386 applet fonts
charsets.jar / \
/ \
localedata.jar server client

Como se puede observar, la estructura se encuentra dividida en tres grandes partes :
bin: Incluye los ejecutables para la generación de programas Java.
lib: Contiene las librerías (Clases) base empleadas en la generación de la gran mayoría de programas Java.
jre: Incluye el ambiente necesario para ejecutar programas Java, el cual a su vez se encuentra sub-dividido en distintos directorios.

Algunas caracteristicas son:
- Inclusión de las principales herramientas para desarrollo de aplicaciones.
- Inclusión de un potente editor que trabaja con el lenguaje Java, además tiene acceso a diferentes aplicaciones externas y a la documentación de las APIs.
- Integración con la maquina virtual para poder compilar y ejecutar directamente nuestras creaciones.
En conclusión, si te quieres introducir en el lenguaje de programación Java, entonces esta herramienta no puede faltar en tu ordenador.

¿Qué es JRE?
JRE es el acrónimo de Java Runtime Environment (entorno en tiempo de ejecución Java) y se corresponde con un conjunto de utilidades que permite la ejecución de programas java sobre todas las plataformas soportadas.

JRE es además un producto presente en la mayoría de clientes, que lo usan como plugin del navegador, de ahí la importancia de mantener actualizado el sistema. Se han dado bastantes casos de malware que ha intentado aprovechar vulnerabilidades en JRE para ejecutar código arbitrario en el sistema. Sin embargo, el hecho de que existan varias ramas en desarrollo (1.4.x, 5.x, 6.x...) con saltos de versiones y cambios en la nomenclatura, unido al hecho de que pueden convivir varias ramas en un mismo sistema de forma que necesiten actualización por separado, hacen que el mantenimiento de esta máquina virtual resulte confuso para muchos usuarios.

El usuario final usa el JRE como parte de paquetes software o plugins (o conectores) en un navegador Web. Sun ofrece también el SDK de Java 2, o JDK (Java Development Kit) en cuyo seno reside el JRE, e incluye herramientas como el compilador de Java, Javadoc para generar documentación o el depurador. Puede también obtenerse como un paquete independiente, y puede considerarse como el entorno necesario para ejecutar una aplicación Java, mientras que un desarrollador debe además contar con otras facilidades que ofrece el JDK.

http://es.wikipedia.org/wiki/Java
http://es.wikipedia.org/wiki/JRE
http://es.wikipedia.org/wiki/JDK
http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_Java
http://www.mp3.es/Es/Java_Runtime_Environment_(JRE)
Biblioteca de consulta Encarta 2004.