Prueba.

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

public class movcircular extends JApplet {

public void init() {
// TODO start asynchronous download of heavy resources
}

public void paint(Graphics g){
g.setColor(Color.BLUE);
g.drawString("EL RADIO ES 10m", 10,10);
g.setColor(Color.BLACK);
g.drawOval(50,50 , 100, 100);
String aux=JOptionPane.showInputDialog(null,"VALOR DE LA ANGULO","ANGULO",JOptionPane.DEFAULT_OPTION);
int temp = Integer.parseInt(aux);
g.setColor(Color.LIGHT_GRAY);
g.fillArc(50, 50, 100, 100,0,temp*360/360);
g.setColor(Color.BLUE);
g.drawString("EL ANGULO ES:"+temp, 10,20);
g.setColor(Color.RED);

int t= 2;
int wo= 0;
double w= 0;
double wf=0;
double ae;
double ve;

w=temp/t;
g.drawString("W: "+w, 200,20);

int[]v= new int[2];
v[0]=-10; v[1]=-20;
double[]a= new double[2];
a[0]=-2.3; a[1]=-1.8;

ae= Math.sqrt(Math.pow(a[0],2)) + Math.pow(a[1],2);
ve= Math.sqrt(Math.pow(a[0],2)) + Math.pow(a[1],2);

wf = wo + ae*t;
g.drawString("wf: "+wf, 200,40);


double vf = 10*w ;
g.drawString("vf: "+vf, 200,60);

g.setColor(Color.MAGENTA);
g.drawOval(95,95, 8, 8);
g.drawOval(73,50, 8, 8);



}

dinamica 2

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

/**
*
* @author program
*/
public class Dinamica extends JApplet {

/**
* Initialization method that will be called after the applet is loaded
* into the browser.
*/
public void init() {
// TODO start asynchronous download of heavy resources
}

public void paint(Graphics g){
String aux=JOptionPane.showInputDialog(null,"VALOR DE LA BASE","BASE",JOptionPane.PLAIN_MESSAGE);
double x= Double.parseDouble(aux);
g.drawLine(30,150,(int)x+30,150 );
String aux2=JOptionPane.showInputDialog(null,"VALOR DE LA ALTURA","ALTURA",JOptionPane.DEFAULT_OPTION);
double y =Double.parseDouble(aux2);
g.drawLine((int)x+30, 150,(int)x+30,150-(int)y);
g.drawLine(30, 150, (int)x+30, 150-(int)y);

double angulo;
double tan=y/x;
angulo=Math.atan(tan);
angulo=Math.toDegrees(angulo);

String aux8=JOptionPane.showInputDialog(null,"DISTANCIA DE INICIO","DISTANCIA",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.darkGray);
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,"VALOR DE LA FUERZA","FUERZA",JOptionPane.DEFAULT_OPTION);
double fuerza=Double.parseDouble(aux3);
String aux4=JOptionPane.showInputDialog(null,"VALOR DE LA MASA","MASA",JOptionPane.DEFAULT_OPTION);
double masa=Double.parseDouble(aux4);
String aux5=JOptionPane.showInputDialog(null,"VALOR DEL COEFICIENTE DE ROZAMIENTO","COEFICIENTE DE ROZAMIENTO",JOptionPane.DEFAULT_OPTION);
double miu=Double.parseDouble(aux5);
String aux6=JOptionPane.showInputDialog(null,"VALOR DEL TIEMPO","TIEMPO",JOptionPane.DEFAULT_OPTION);
double tiempo=Double.parseDouble(aux6);

double gravedad=9.8;
double aceleracion;
aceleracion=(fuerza/masa)-(gravedad*((miu*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.MAGENTA);
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("µ",(int)(xo+xn-xb+(0.5*d)-frx-15),(int)(yo-yn-yb-dx+fry));

g.setColor(Color.ORANGE);
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("N",(int)(xo+xn-xb+(0.5*d)-nx-20),(int)(yo-yn-yb-dx-ny));
g.setColor(Color.PINK);
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.setColor(Color.BLUE);
g.drawString("La FUERZA es ", 180,60);
g.drawString("La MASA es ", 180,80);
g.drawString("El TIEMPO es ", 180,100);
g.drawString("El ROZAMIENTO es ", 180,120);
g.drawString("La ACELERACION es ", 180,140);
g.drawString("El DESPLAZAMIENTO es ", 180,160);

g.setColor(Color.BLACK);
g.drawString(""+fuerza, 320,60);
g.drawString(""+(short)masa, 320,80);
g.drawString(""+tiempo, 320,100);
g.drawString(""+miu, 320,120);
g.drawString(""+(short)aceleracion, 320,140);
g.drawString(""+(short)desplazamiento, 320,160);
}
}

Dinamica

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

public class Calculo 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);
g.setColor(Color.BLUE);
g.drawString("la base:"+base, 35,20);
g.drawString("Altura:"+altura,35,30);
double tan=altura/base;
angulo=Math.atan(tan);
angulo=Math.toDegrees(angulo);
g.drawString("el angulo es: "+angulo, 35,40 );

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);
//g.drawLine(10,100,(int)fuerza+10, 150-(int)fuerza);
String aux4=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DE LA MASA","MASA EN KILOGRAMOS",JOptionPane.DEFAULT_OPTION);
double masa=Double.parseDouble(aux4);
//g.setColor(Color.orange);
//g.drawLine(10,100,(int)masa+30 ,150-(int)masa);
String aux5=JOptionPane.showInputDialog(null,"INGRESE EL VALOR DEL COEFICIENTE DE ROZAMIENTO","COEFICIENTE DE ROZAMIENTO",JOptionPane.DEFAULT_OPTION);
double miu=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*((miu*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.MAGENTA);
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.BLACK);
g.drawLine(150, 25, 350, 25);
g.drawLine(150, 25,150,160);
g.drawLine(150, 160, 350, 160);

//g.drawLine(320, 30, 320, 150);
g.setColor(Color.magenta);
g.drawString("FUERZA", 160,44);
g.drawString(""+fuerza, 300,44);
g.drawString("MASA", 160,59);
g.drawString(""+(int)masa, 300,59);
g.drawString("TIEMPO", 160,74);
g.drawString(""+tiempo, 300,74);
g.drawString("MIU", 160,89);
g.drawString(""+miu, 300,89);
g.drawString("ACELERACION", 160,104);
g.drawString(""+(short)aceleracion, 300,104);
g.drawString("DESPLAZAMIENTO", 160,119);
g.drawString(""+(short)desplazamiento, 300,119);
g.drawString("FUERZA NORMAL", 160,134);
g.drawString(""+(short)(miu*masa*gravedad*Math.cos(angulo*Math.PI/180)), 300,134);
g.drawString("ANGULO PLANO", 160,149);
g.drawString(""+(short)angulo, 300,149);
}
}

Termometro

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

import java.awt.*;

public class MedidorGrad extends JApplet{
public void Int(){

}
public void paint(Graphics g){
g.drawRect(200, 50, 20, 100);
g.drawOval(20, 30, 50, 50);
g.drawString("-10c ", 230, 150);
g.drawString("+100c ", 230, 50);
String aux = JOptionPane.showInputDialog(null, "INGRESE EL VALOR","TITULO",JOptionPane.CANCEL_OPTION);
int temp = Integer.parseInt(aux);
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);

}
}

Porcentaje

package porrcentaje;

/**
*
* @author program
*/
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JApplet;
import javax.swing.JOptionPane;


public class Por100 extends JApplet{
public void Int(){

}
public void paint(Graphics g){
g.drawOval(100, 50, 100, 100);
g.setColor(Color.BLUE);
g.drawString("PORCENTAJE", 150, 15);
g.setColor(Color.PINK);
String aux = JOptionPane.showInputDialog(null, "INGRESE EL PORCENTAJE","TITULO",JOptionPane.DEFAULT_OPTION);
int temp = Integer.parseInt(aux);

g.drawString(" "+temp+"%",50,100-temp);

g.setColor(Color.darkGray);
if(temp > 80){
g.setColor(Color.RED);
g.fillOval(120, 30, 100,100-temp);
g.drawString("ALERTA", 30, 100);
g.fillArc(100, 50, 100, 1000,0,(temp*360)/100);
}
g.fillArc(100, 50, 100, 100,0,(temp*360)/100);


}
}

trabajo

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

private JPanel panelMatriz;
private JTextField[][]blancos;
private int numeroColumnas;
private int numeroFilas;


public Panelejer(){
super("MENU DE OPERACIONES");

String aux1="PROGRAMA DE OPERACIONES CON MATRICES\n";
aux1+="ESCOJA UNA OPCION Y DIGITE:\n1.-SUMA\n2.-RESTA\n3.-MULTIPLICACION\n";
String aux=JOptionPane.showInputDialog(null,aux1,JOptionPane.DEFAULT_OPTION);
double d= Double.parseDouble(aux);
if (d==1){
String aux9="SUMA";
JOptionPane.showMessageDialog(null,(d)+aux9,"OPCION ESCOGIDA",JOptionPane.DEFAULT_OPTION);}
if(d==2){
String aux9="RESTA";
JOptionPane.showMessageDialog(null,(d)+aux9,"opcion escogida",JOptionPane.DEFAULT_OPTION);}
if(d==3){
String aux9="MULTIPLICACION";
JOptionPane.showMessageDialog(null,(d)+aux9,"opcion escogida",JOptionPane.DEFAULT_OPTION);}

String aux2="INGRESE";

aux2+="NUMERO DE FILAS: \n";
String aux3=JOptionPane.showInputDialog(null,aux2,JOptionPane.DEFAULT_OPTION);
double m= Double.parseDouble(aux3);
JOptionPane.showMessageDialog(null,""+(m),"NUMERO DE FILAS",JOptionPane.DEFAULT_OPTION);
String aux4="INGRESE";
aux4+="NUMERO DE COLUMNAS.\n";
String aux5=JOptionPane.showInputDialog(null,aux4,JOptionPane.DEFAULT_OPTION);
double n= Double.parseDouble(aux5);
JOptionPane.showMessageDialog(null,""+(n),"NUMERO DE COLUMNAS",JOptionPane.DEFAULT_OPTION);

numeroFilas=(int)m;
numeroColumnas=(int)n;
contenedor= getContentPane();
blancos=new JTextField[numeroFilas][numeroColumnas];
panelMatriz=new JPanel(new GridLayout(numeroFilas,numeroColumnas,5,5));
for(int i=0;i for(int j=0;j blancos[i][j]=new JTextField("blanco"+i+" "+j);
panelMatriz.add(blancos[i][j]);
}
contenedor.add(panelMatriz, BorderLayout.NORTH);
setSize(800,600);
setVisible(true);
}
}

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

}

Ejercicio Panel

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 JButton[][]botones;
private JLabel [][]texto;
private JPanel panelInterD;
private JTextField [][] text;
private JPanel panelInterI;


public DemoPanel(){
super("MI PANEL");
botones= new JButton[2][2];
contenedor = getContentPane();
panelInicio = new JPanel(new GridLayout(2,2));
String [] nombres ={"Enero", "Febrero", "Marzo", "Abril"};

int k =0;
for(int i = 0; i<2; i++){
for(int j = 0; j<2; j++){
botones[i][j] = new JButton(nombres[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];
panelInterD = 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);
panelInterD.add(text[i][j]);
}
}
contenedor.add(panelInterD, BorderLayout.WEST);

text = new JTextField [2][4];
panelInterI = 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);
panelInterI.add(text[i][j]);
}
}
contenedor.add(panelInterI, BorderLayout.EAST);

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

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

}

}

Grafica del msen(ax+b)- mcos(ax+b)

import java.applet.Applet;
import java.awt.*;
public class senx extends Applet {
public void paint(Graphics g){
this.setSize(800, 450);
int a=1;
int b=1;
double m=1;
g.setColor(Color.ORANGE);
g.drawString("y = MSen (ax+b)", 400, 60);
g.drawString("Y = f(x)",100,80);
g.drawString("-Y = f(x)",100,420);
g.drawString("0",90,305);
g.drawString("X = Rad",620,300);
//g.drawString("π/2",180,300);
//g.drawString("π",290,290);
//g.drawString("3π/2",360,300);
//g.drawString("2π",450,290);
g.setColor(Color.black);


for(int i=0; i<360; i=i+2){
int c=a*i+b;
int k=(int) (300 - 100*(Math.sin(c*3.1416/180)));
k= k*(int)m;
int n=(int) (300 - 100*(Math.cos(c*3.1416/180)));
int o =a*i+b;
g.setColor(Color.yellow);
g.fillOval( 100 + i,k,6,6);
g.setColor(Color.CYAN);
g.fillOval( 100 + i,n,6,6);
g.setColor(Color.RED);
g.fillOval(i, o, 1, 1);}

g.drawLine(100, 100, 100, 400);
g.drawLine(100, 300, 600, 300);
}
}

Grafico de la Funcion Sen

public class FuncionSenApplet extends Applet {
public void paint(Graphics g){
g.drawString("Carolina Pinto", 190, 79);
g.drawString("seno", 199, 79);
g.drawString("y=",200 , 80);
g.drawLine(40, 40, 40, 450);
g.drawLine(20, 270, 450, 270);
g.setColor(Color. BLUE);
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.RED); 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.BLACK);

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.BLUE);

g.drawString("X ", 460, 270);

g.drawString("Y ", 25, 35);

int ymax=this.getHeight();

int xmax=this.getWidth();

this.setSize(800, 800);

} }

Ciclos de Vida de un Applet

CICLO DE VIDA DE UN APPLET

Deberías ver "initializing... starting..." arriba, como resultado de la carga del applet.

Cuando se carga un applet, aquí está lo que sucede:

Se crea un ejemplar de la clase que controla el applet (una subclase de Applet).
El applet se auto-initializa.
El applet empieza su ejecución.

Cuando un usuario deja la página del applet. Cuando el usuario retorna a la página, el applet puede autoarrancarse otra vez. La misma secuencia ocurre cuando el usuario minimiza y reabre la ventana que contiene el applet.

Algunos navegadores nos permiten recargar el applet, que consiste en descargar el applet y volver a cargarlo de nuevo. Para que el applet pueda liberar cualquier recurso que contenga el applet. Después de esto, el applet es descargado y luego cargado otra vez, como se decribe en Cargar el Applet.

Salir del Navegador
Cuando el usuario cierra el navegador, el applet tiene la oportunidad de pararse y hacer una limpieza final antes de que el navegador salga.

Un Applet puede reaccionar ante los eventos mayores de las siguientes formas:
Puede auto-inicializarse.
Puede arrancar su ejecución.
Puede parar su ejecución.
Puede realizar una limpieza final, como preparación para ser descargado.

MRU y MRUV (WITH APPLET)

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:

Matriz m = new Matriz(1,3);
double aux = Double.parseDouble(jTextField1.getText());
m.matriz[0][0]=aux;
aux= Double.parseDouble(jTextField4.getText());
m.matriz[0][1]=aux;
aux= Double.parseDouble(jTextField11.getText());
m.matriz[0][2]=aux;

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

Matriz o = new Matriz(1,3);
aux = Double.parseDouble(jTextField3.getText());
o.matriz[0][0]=aux;
aux= Double.parseDouble(jTextField2.getText());
o.matriz[0][1]=aux;
aux= Double.parseDouble(jTextField12.getText());
o.matriz[0][2]=aux;

jTextArea1.setText((o.suma(m.multiplicaEscalar(t))).imprimir());
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
Matriz m = new Matriz(1,3);
double aux = Double.parseDouble(jTextField1.getText());
m.matriz[0][0]=aux;
aux= Double.parseDouble(jTextField4.getText());
m.matriz[0][1]=aux;
aux= Double.parseDouble(jTextField11.getText());
m.matriz[0][2]=aux;
jTextArea1.setText("Velocidad constante");
jTextArea1.setText(m.imprimir());
}

private void jTextField11ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}

private void jTextField12ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}

private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:

Matriz m = new Matriz(1,3);
double aux = Double.parseDouble(jTextField5.getText());
m.matriz[0][0]=aux;
aux= Double.parseDouble(jTextField6.getText());
m.matriz[0][1]=aux;
aux= Double.parseDouble(jTextField13.getText());
m.matriz[0][2]=aux;

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

Matriz o = new Matriz(1,3);
aux = Double.parseDouble(jTextField7.getText());
o.matriz[0][0]=aux;
aux= Double.parseDouble(jTextField8.getText());
o.matriz[0][1]=aux;
aux= Double.parseDouble(jTextField14.getText());
o.matriz[0][2]=aux;

Matriz a = new Matriz(1,3);
aux = Double.parseDouble(jTextField15.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;


jTextArea1.setText((o.suma(m.multiplicaEscalar(t)).suma(a.multiplicaEscalar(t*t*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(jTextField5.getText());
Vo.matriz[0][0]=aux;
aux= Double.parseDouble(jTextField6.getText());
Vo.matriz[0][1]=aux;
aux= Double.parseDouble(jTextField7.getText());
Vo.matriz[0][2]=aux;

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

Matriz a = new Matriz(1,3);
aux = Double.parseDouble(jTextField15.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;

jTextArea1.setText((Vo.suma(a.multiplicaEscalar(t))).imprimir());


}


// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel10;
private javax.swing.JLabel jLabel11;
private javax.swing.JLabel jLabel12;
private javax.swing.JLabel jLabel13;
private javax.swing.JLabel jLabel14;
private javax.swing.JLabel jLabel15;
private javax.swing.JLabel jLabel16;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JLabel jLabel8;
private javax.swing.JLabel jLabel9;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea jTextArea1;
private javax.swing.JTextField jTextField1;
private javax.swing.JTextField jTextField10;
private javax.swing.JTextField jTextField11;
private javax.swing.JTextField jTextField12;
private javax.swing.JTextField jTextField13;
private javax.swing.JTextField jTextField14;
private javax.swing.JTextField jTextField15;
private javax.swing.JTextField jTextField16;
private javax.swing.JTextField jTextField17;
private javax.swing.JTextField jTextField2;
private javax.swing.JTextField jTextField3;
private javax.swing.JTextField jTextField4;
private javax.swing.JTextField jTextField5;
private javax.swing.JTextField jTextField6;
private javax.swing.JTextField jTextField7;
private javax.swing.JTextField jTextField8;
private javax.swing.JTextField jTextField9;
// End of variables declaration

}

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.

Un Java applet es un código JAVA que carece de un método main, por eso se utiliza principalmente para el trabajo de páginas web, ya que es un pequeño programa que es utilizado en una página HTML y representado por una pequeña pantalla gráfica dentro de ésta.

Por otra parte, la diferencia entre una aplicación JAVA y un applet radica en cómo se ejecutan. Para cargar una aplicación JAVA se utiliza el intérprete de JAVA (pcGRASP de Auburn University, Visual J++ de Microsoft, Forte de Sun de Visual Café). En cambio, un applet se puede cargar y ejecutar desde cualquier explorador que soporte JAVA (Netscape, Internet Explorer de Windows, Mozilla Firefox...etc).

Obtenido de "http://es.wikipedia.org/wiki/Applet"

Herencias

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 Matriz productoCruz(Vector X){

Matriz resultado;
resultado = X.transpueta();
resultado = this.multiplica(resultado);
return resultado;
}
public static void main (String [] args){

Vector v = new Vector(1,3);
v.matriz[0][0]=1;
v.matriz[0][1]=0;
v.matriz[0][2]=1;
//v.transpueta();
System.out.println(v.transpueta().imprimir());

Vector v1 = new Vector(1,3);
v1.matriz[0][0]=1;
v1.matriz[0][1]=2;
v1.matriz[0][2]=3;

Matriz respuesta;
respuesta=v.productoCruz(v1);

System.out.println(v1.transpueta().imprimir());
System.out.print(v.suma(v1).imprimir());
System.out.println("resultado del producto cruz\n"+respuesta.imprimir());
//System.out.print("producto escalar"+v.productoEscalar(v1));
}
}

SWING Y AWT

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.
El paquete Swing es parte de la JFC (Java Foundation Classes) en la plataforma Java. La JFC provee facilidades para ayudar a la gente a construir GUIs. Swing abarca componentes como botones, tablas, marcos, etc...
Las componentes Swing se identifican porque pertenecen al paquete javax.swing.
Swing existe desde la JDK 1.1 (como un agregado). Antes de la existencia de Swing, las interfaces gráficas con el usuario se realizaban a través de AWT (Abstract Window Toolkit), de quien Swing hereda todo el manejo de eventos. Usualmente, para toda componente AWT existe una componente Swing que la reemplaza, por ejemplo, la clase Button de AWT es reemplazada por la clase JButton de Swing (el nombre de todas las componentes Swing comienza con "J").

Cuando se empieza a utilizar Swing, se observa que JavaSoft ha dado un gran paso adelante respecto al AWT. Ahora los Componentes del interfaz gráfico son Beans y utilizan el nuevo modelo de Delegación de Eventos de Java. Swing proporciona un conjunto completo de Componentes, todos ellos lightweight, es decir, ya no se usan componentes "peer" dependientes del sistema operativo, y además, Swing está totalmente escrito en Java. Todo ello redunda en una mayor funcionalidad en manos del programador, y en la posibilidad de mejorar en gran medida la cosmética de los interfaces gráficos de usuario.

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.

AWT
(Abstract Window Toolkit). API de Java que permite a los programadores hacer aplicaciones JAVA con componentes GUI (como ventanas, botones, barras, campos de texto, etc.).
AWT es el acrónimo del X Window Toolkit para Java, donde X puede ser cualquier cosa: Abstract, Alternative, Awkward, Another o Asqueroso; aunque parece que Sun se decanta por Abstracto, seriedad por encima de todo. Se trata de una biblioteca de clases Java para el desarrollo de Interfaces de Usuario Gráficas. La versión del AWT que Sun proporciona con el JDK se desarrolló en sólo dos meses y es la parte más débil de todo lo que representa Java como lenguaje. El entorno que ofrece es demasiado simple, no se han tenido en cuenta las ideas de entornos gráficos novedosos, sino que se ha ahondado en estructuras orientadas a eventos, llenas de callbacks y sin soporte alguno del entorno para la construcción gráfica; veremos que la simple acción de colocar un dibujo sobre un botón se vuelve una tarea harto complicada. Quizá la presión de tener que lanzar algo al mercado haya tenido mucho que ver en la pobreza de AWT.

JavaSoft, asegura que esto sólo era el principio y que AWT será multi-idioma, tendrá herramientas visuales, etc. En fin, al igual que dicen los astrólogos, el futuro nos deparará muchas sorpresas.

La estructura básica del AWT se basa en Componentes y Contenedores. Estos últimos contienen Componentes posicionados a su respecto y son Componentes a su vez, de forma que los eventos pueden tratarse tanto en Contenedores como en Componentes, corriendo por cuenta del programador (todavía no hay herramientas de composición visual) el encaje de todas las piezas, así como la seguridad de tratamiento de los eventos adecuados. Nada trivial.

No obstante y pese a ello, vamos a abordar en este momento la programación con el AWT para tener la base suficiente y poder seguir profundizando en las demás características del lenguaje Java, porque como vamos a ir presentando ejemplos gráficos es imprescindible el conocimiento del AWT. Mientras tanto, esperemos que JavaSoft sea fiel a sus predicciones y lo que ahora veamos nos sirva de base para migrar a un nuevo y maravilloso AWT.

MRUV

package vectorial;
public class MRUVari{
public Particula particula;

public MRUVari(){}
public MRUVari(Matriz x0, Matriz v0, Matriz a){
particula = new Particula();
particula.setDesplazamientoRealizado(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}
public Matriz calcularDesplazamiento(double t){
Matriz posicion;
Matriz x0, v0, a;
x0 = this.particula.getDesplazamientoRealizado();
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.getDesplazamientoRealizado().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]=13.61; v0.matriz[0][1]=15.83; 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;
MRUV m = new MRUV(x0,v0,a);

Matriz x;
x = m.calcularDesplazamiento(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());
}
}
public class Particula {
private Matriz DesplazamientoRealizado;
private Matriz velocidadInicial;
private Matriz aceleracion;

public Particula(){}
public Particula(Matriz dR, Matriz vI, Matriz a){
DesplazamientoRealizado = dR;
velocidadInicial = vI;
aceleracion = a;
}public Matriz getDesplazamientoRealizado(){
return DesplazamientoRealizado;
}public void setDesplazamientoRealizado(Matriz dR){
DesplazamientoRealizado = dR;
}public Matriz getAceleracion(){
return aceleracion;
}public void setAceleracion(Matriz a){
aceleracion = a;
}public Matriz getVelocidadInicial(){
return velocidadInicial;
}public void setVelocidadInicial(Matriz vI){
velocidadInicial = vI;
}}
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 < numeroFilas; i++){
for(int j = 0; j < numeroColumnas; j++){
aux = aux + matriz[i][j] +" ";
}
aux = aux + "\n";
}
return aux;
}
public String imprimir4(){
String aux ="";
aux="("+aux+ matriz[0][0]+"i"+" ";
aux=aux+matriz[0][1]+"j"+" ";
aux=aux+matriz[0][2]+"k"+")";
return aux;
}

MRU

package capsula;

/**
*
* @author Operador
*/

public class Particula {

private double distanciaRecorrida;
private double velocidadInicial;
private double velocidadFinal;
private double velocidadMedia;
private double aceleracion;


public Particula(){}

public Particula(double dR, double vM, double a){
distanciaRecorrida = dR;
velocidadMedia = vM;
aceleracion = a;
}

public double getdistanciaRecorrida(){
return distanciaRecorrida;
}

public void setdistanciaRecorrida(double pI){
distanciaRecorrida = pI;}
public double getAceleracion(){
return aceleracion;}
public void setAceleracion(double a){
aceleracion = a;}

public double getVelocidadMedia(){
return velocidadMedia;
}
public void setVelocidadMedia(double vM){
velocidadMedia = vM;
}
public double getVelocidadInicial(){
return velocidadInicial;
}
public void setVelocidadInicial(double vI){
velocidadInicial = vI;
}
public double getVelocidadFinal(){
return velocidadFinal;
}
public void setVelocidadFinal(double vF){
velocidadFinal = vF;
}
}
package capsula;

/**
*
* @author Operador
*/

public class MovRecUNi {
public Particula particula;

public MovRecUNi(){}
public MovRecUNi(double x0, double v0, double a, double vI){
Particula.setdistanciaRecorrida(x0);
Particula.setVelocidadMedia(v0);
Particula.setAceleracion(a);
Particula.setVelocidadInicial(vI);
}
public double calculoAceleracion(double t){
double aceleracion = particula.getVelocidadFinal()/t;
return aceleracion;
}
public double calculoVelocidad(double t){
double velocidad = particula.getVelocidadFinal()/2;
return velocidad;
}
public double calcularDistancia(double t){
double Distancia;
Distancia = particula.getVelocidadInicial()*t +particula.getAceleracion()*t*t*0.5;
return Distancia;
}}
public class Prueba {
public static void main(String args[]){
Particula p = new Particula(0.0,0.0,0);
System.out.println(p.getdistanciaRecorrida());
p.setVelocidadInicial(0);
p.setVelocidadFinal(20.87);
System.out.println("Velocidad Inicial = "+p.getVelocidadInicial());
System.out.println("Velocidad final = "+p.getVelocidadFinal());
System.out.println("\n");
MovRecUNi m = new MovRecUNi();
m.particula=p;
System.out.println("Cuando t=120 segundos\n");
System.out.println("Aceleracion = "+m.calculoAceleracion(120));
System.out.println("Velocidad = "+m.calculoVelocidad(120));
System.out.println("La Distancia = "+m.calcularDistancia(120));
}
}

Respuestas:

respuestas:
x1 + 2x2 + x3 =0
x1 +x2 = 1
-x1 -2x2= -3


x1= -1
x2= 2
x3= 3.

2.- x1= 1
x2= 0
x3= 1
x4= 0
x5= 0

3.- a + b = 4 + 2 + 4 ;

4.- a - b = 0 + 4 + 4 ;

5.- a transpuesta b = 4 -2 0
6 -3 0
8 -4 0

Sistema de Ecuaciones

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 imprimir1(){
String aux ="";
for(int i = 0; i < numeroFilas; i++){
for(int j = 0; j < numeroColumnas; j++){
aux = aux + matriz[i][j] +" ";
}
aux = aux + "\n";
}
return aux;
}
public String imprimir2(){
String aux ="";
aux=aux+"x1="+ matriz[0][0];
aux=aux+"\n";
aux=aux+"x2="+matriz[1][0];
return aux;
}
public Matriz multiplicacion(Matriz B){
if(this.numeroFilas==B.numeroColumnas){
Matriz r =new Matriz(this.numeroFilas,this.numeroColumnas);
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;
}
else{
Matriz r=new Matriz(1,1);
System.out.println("NO SE PUEDE OPERAR");
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
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
for(int j=0;j
result.matriz[i][j]=I.matriz[i][j+this.numeroColumnas];
return result;
}

public static void main(String args[]){
Matriz x=new Matriz(2,2);
x.matriz[0][0]=1;x.matriz[0][1]=1;
x.matriz[1][0]=-1;x.matriz[1][1]=2;
System.out.println("la matriz x es:");
System.out.println(x.imprimir1());
Matriz y=new Matriz(2,2);
y.matriz[0][0]=1;
y.matriz[1][0]=0;
System.out.println("la matriz y es:");
System.out.println(y.imprimir1());

matriz resultado;
resultado=x.inversa();
System.out.println("la matriz inversa de x es:");
System.out.println(resultado.imprimir1());
resultado=y.inversa().multiplicacion(y);
System.out.println("las soluciones del sistema:");
System.out.printlin();
System.out.println(resultado.imprimir2());
}

}

matriz de deber

package trabafinal;
/**
*
* @author Operador
*/

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

/*Matriz a=(Matriz)c.clone();
/*Matriz b=(Matriz)d.clone();
private Object c;*/


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 < numeroFilas; i++){
for(int j = 0; j < numeroColumnas; j++){
aux = aux + matriz[i][j] +" "; }
aux = aux + "\n"; }
return aux; }


public Matriz inversa(){

Matriz c=new Matriz(this.numeroColumnas,this.numeroFilas);
c.matriz[1][0]=(((this.matriz[1][0]/this.matriz[1][0])*(this.matriz[0][0]))-(this.matriz[0][0]));
c.matriz[1][1]=(((this.matriz[1][1]/this.matriz[1][0])*(this.matriz[0][1]))-(this.matriz[0][1]));
c.matriz[0][1]=(((this.matriz[0][1]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[1][1]));
c.matriz[0][0]=(((this.matriz[0][0]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[0][0]));
return c;
}
public Matriz inversa2(){
Matriz d=new Matriz(this.numeroColumnas,this.numeroFilas);
d.matriz[1][0]=(((this.matriz[1][0]/this.matriz[1][0])*(this.matriz[0][0]))-(this.matriz[0][0]));
d.matriz[1][1]=(((this.matriz[1][1]/this.matriz[1][0])*(this.matriz[0][1]))-(this.matriz[0][1]));
d.matriz[0][1]=(((this.matriz[0][1]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[1][1]));
d.matriz[0][0]=(((this.matriz[0][0]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[0][0]));
return d;
}
public Matriz multiplicacion(Matriz e){

if((this.numeroFilas == e.numeroFilas)&(this.numeroColumnas == e.numeroColumnas)){
Matriz c = new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
for(int i=0; ifor(j=0; jc.matriz[i][j]= this.matriz[i][j]*e.matriz[i][j];
return e;
} else{
Matriz r = new Matriz (1,1);
System.out.println("No se pueden multiplicar las matrices");
return r;
}

}

public Object clone(){
Matriz obj=null;
try{
obj=(Matriz)super.clone();
}catch(CloneNotSupportedException ex){
System.out.println(" no se puede duplicar");
}
obj.a=(int[][])obj.c.clone();
for(int i=0; i obj.c[i]=(int[])obj.c[i].clone();
}
return obj;
}

public static void main(String args[]){


Matriz a = new Matriz(2, 2);
a.matriz[0][0]=1;a.matriz[0][1]=-1;
a.matriz[1][0]=2;a.matriz[1][1]=1;

System.out.println("la matriz a es:");
System.out.println(a.imprimir());

Matriz b = new Matriz(2, 2);
b.matriz[0][0]=1;
b.matriz[1][1]=1;

System.out.println("la matriz b es:");
System.out.println(a.imprimir());

Matriz e = new Matriz(1, 1);
e.matriz[0][0]=3;
e.matriz[0][1]=4;

System.out.println("la matriz e es:");
System.out.println(a.imprimir());

}

}
lo que falta es para que se copie la matriz a en c y b en d...

matriz multiplicacion, matriz inversa

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){
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 multiplicar las matrices");
return r;
}
}
public Matriz inversa(){
Matriz r=new Matriz(this.numeroColumnas,this.numeroFilas);
r.matriz[0][0]=((this.matriz[1][1]*this.matriz[2][2])-(this.matriz[2][1]*this.matriz[1][2]));
r.matriz[0][1]=((this.matriz[1][0]*this.matriz[2][2])-(this.matriz[2][0]*this.matriz[1][2]));
r.matriz[0][2]=((this.matriz[1][0]*this.matriz[2][1])-(this.matriz[2][0]*this.matriz[1][1]));
r.matriz[1][0]=((this.matriz[0][1]*this.matriz[2][2])-(this.matriz[2][1]*this.matriz[0][2]));
r.matriz[1][1]=((this.matriz[1][0]*this.matriz[2][2])-(this.matriz[2][0]*this.matriz[1][2]));
r.matriz[1][2]=((this.matriz[0][0]*this.matriz[2][1])-(this.matriz[2][0]*this.matriz[0][1]));
r.matriz[2][0]=((this.matriz[0][1]*this.matriz[1][2])-(this.matriz[1][1]*this.matriz[0][2]));
r.matriz[2][1]=((this.matriz[0][0]*this.matriz[1][2])-(this.matriz[1][0]*this.matriz[0][2]));
r.matriz[2][2]=((this.matriz[0][0]*this.matriz[1][1])-(this.matriz[1][0]*this.matriz[0][1]));
return r;

}

public static void main(String args[]){
Matriz m = new Matriz(3, 3);
m.matriz[0][0]=1;
m.matriz[1][1]=1;
m.matriz[2][2]=1;
System.out.println("la matriz m es:");
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("la matriz b es:");
System.out.println(b.imprimir());

Matriz resultado;

resultado = m.multiplicacion(b);
System.out.println(resultado.imprimir());
resultado=m.inversa();
System.out.println("la matriz inversa de m es:");
System.out.println(resultado.imprimir());
resultado=b.inversa();
System.out.println("la matriz inversa de b es:");
System.out.println(resultado.imprimir());
}
}

La Programación Orientada a Objetos

La Programación Orientada a Objetos

Es un paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y programas de computadora. Está basado en varias técnicas, incluyendo herencia, modularidad, polimorfismo y encapsulamiento. Su uso se popularizó a principios de la década de 1990. Actualmente son muchos los lenguajes de programación que soportan la orientación a objetos.
El concepto de programación orientada a objetos (OOP) no es nuevo, lenguajes clásicos como SmallTalk se basan en ella. Dado que la OOP. se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos, un lenguaje se dice que está basado en objetos si soporta objetos como una característica fundamental del mismo.


El elemento fundamental de la OOP es, como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto complejo de datos y programas que poseen estructura y forman parte de una organización.

Esta definición especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto número de componentes bién estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organización jerárquica o de otro tipo.

Suma de Matrices

public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[]args){

int[]a=new int[5];
int[]b=new int[5];
int[]c=new int[5];
int resp1;int resp2;

a[0]=1; a[1]=1;
a[2]=9; a[3]=9;
a[4]=2;
b[0]=3; b[1]=2;
b[2]=4; b[3]=2;
b[4]=2;

System.out.print("DEBER DE SUMAR VARIOS NUMEROS");
System.out.println();

for(int i=4;i>2;i--)
{
//la suma de matrices a[]+b[]

c[i]= a[i] + b[i];
resp1=c[i];
if(resp1>=10)
c[i]=resp1-10;
}

// numero que los divida en 2 partes..

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

if(resp2>=10)
c[i]=resp2-10;
}
c[0]=a[0]+b[0];
for(int i=0;i<5;i++)
System.out.print(c[i]);
}
}

ARREGLOS

Los arreglos en Java son objetos, demostrando el compromiso de Java con la orientación a objetos.

En java a diferencia del lenguaje C, existe un tipo de variable “especial”, el Array. Este tipo de variables no es más que un conjunto secuencial de memoria a las que se accede a través de un índice de posición.

Los arreglos en Java son objetos, por lo que cuentan con propiedades y métodos para manipularlos. Se pueden declarar arreglos de tipos de datos primitivos y de objetos.

Más abajo tienes la sintaxis básica de declaración de arrays.

Sintaxis:

tipodedato nombre [] [= new tipodedato[capacidad]] o
tipodedato[] nombre [= new tipodedato[capacidad]]



Como puedes observar puedes inicializar un array al momento de declararlo o postergar esta operación para cuando sea necesario.

Para inicializar un array existen 2 maneras:

int[] arreglo=new int[4] o
int[] arreglo={100,200,302,400}



Como podrás concluir la primera declaras el array nada más diciéndole la cantidad de memoria secuencial que se debe reservar, en el segundo ejemplo se inicializa el array dándole los valores que va a contener (obviamente la cantidad de memoria secuencial reservada sera igual a la cantidad de elementos insertados).

Al momento de inicializar un arreglo de la manera :

int[] arreglo=new int[4]
cada posición del arreglo sera inicializada con el valor por defecto del tipo de variable. Por ejemplo si el arreglo si el arreglo es de tipo boolean, todas las posiciones del arreglo serán inicializadas con el valor false (ya que este es valor por defecto de este tipo de dato), por el contrario si el arreglo fuese de un tipo no primitivo, el valor que contendrá cada casilla sera null.


Para obtener el tamaño de un array de manera dinámica se utiliza la propiedad .length, esta propiedad es común para todos los array . También es importante saber que los arreglos se empiezan a enumerar desde el numero (0) cero por tanto para acceder al valor almacenado en la ultima posición deberás colocar el el tamaño del arreglo menos 1 unidad.

Al momento de tratar de acceder a una posición fuera del rango del arreglo se lanzara un exception de tipo java.lang.ArrayIndexOutOfBoundsException (esta exception es una exception no chequeada es por eso que no es necesario colocar un bloque try/catch en el código)

operaciones con vectores

public class Main {


public static void main(String[] args) {
// TODO code application logic here
double []v;
double []w;
double []z;

v=new double [3];
w=new double [3];
z=new double [3];

double product_escalar = 0;
double magnitud = 0;
double resulma =0;
double unitario = 0;
double angulo = 0;
double magnitud1=0;
double producto=0;

v[0]=1 ;v[1]=6; v[2]=4;
w[0]=5 ;w[1]=-2;w[2]=3;

//suma v[i]+w[i]

for(int i=0; i<3 ;i++)
z[i]= w[i]+v[i];

for(int i=0; i<3 ;i++)
System.out.println("EL RESULTADO DE LA SUMA ES: "+z[i]+", ");


// resta v[i]-[i]

for(int i=0; i<3 ;i++)
z[i]= w[i]-v[i];

for(int i=0; i<3 ;i++)
System.out.println("EL RESULTADO DE LA RESTA ES: " + z[i] +" ");

// producto escalar v[i]*[i]

for(int i=0; i<3 ;i++)
product_escalar += w[i]*v[i];

System.out.println("EL RESULTADO DE LA PRODUCTO ESCALAR ES: " +product_escalar);


// magnitud

resulma+=(magnitud= Math.sqrt(Math.pow(w[0],2)+Math.pow(w[1],2)+Math.pow(w[2],2))+(magnitud1= Math.sqrt(Math.pow(v[0],2)+Math.pow(v[1],2)+Math.pow(v[2],2))));

System.out.println("EL RESULTADO DE LA MAGNITUD ES "+resulma);


// unitario
for(int i=0; i<3 ;i++)
unitario += (w[i]+v[i])/resulma;

for(int i=0; i<3 ;i++)
System.out.println("EL RESULTADO DEL UNITARIO ES: " +unitario);

// angulo entre w y v

for(int i=0; i<3 ;i++)
angulo = Math.acos(product_escalar/(magnitud*magnitud1));

for(int i=0; i<3 ;i++)

System.out.println("EL RESULTADO DEL ANGULO ES: " +angulo);

//producto cruz
producto+= (((v[1]*w[2])-(v[2]*w[1]))+((v[0]*w[2])-(v[2]*w[0]))+((v[0]*w[2])-(v[2]*w[0])));

System.out.println("El valor cruz es: " +producto);


}

}

Que es Java, jdk, jre

Que es Java??
Es un lenguaje de programación con el que podemos realizar cualquier tipo de programa, en la actualidad es un lenguaje muy extendido y cada vez cobra más importancia tanto en el ámbito de Internet como en la informática en general.
Una de las principales características es que es un lenguaje independiente de la plataforma. Eso quiere decir que si hacemos un programa en Java podrá funcionar en cualquier ordenador del mercado.

Lenguaje de programacion orientada a objetos. Fue desarrollado por James Gosling y sus compañeros de Sun Microsystems al principio de la década de los 90.

La programación en Java es compilada en bytecode , el cuál es ejecutado por la maquina virtual Java . Usualmente se usa un compilador JIT.
El lenguaje es parecidos a C y C++, aunque su modelo de objetos es más sencillo.

Qué es el JDK (Java Development Kit)

Se trata de un conjunto de programas y librerías que permiten desarrollar (compilar, ejecutar, generar documentación, etc.) programas en lenguaje Java. Existen versiones del JDK para prácticamente todos los Sistemas Operativos y existen también distintos programas comerciales, Sun distribuye gratuitamente el JDK “oficial” para los siguientes sistemas operativos: Windows 95/98/NT, Solaris y Linux

Los JDK incorporan una herramienta de Debugger (detener la ejecución de un programa en la línea que se desee y poder conocer el valor de las variables en ese momento)

Que es JRE (Java Runtime Environment)

Versión reducida del JDK que permite ejecutar código Java, No permite compilar ni utilizar el Debugger .