sábado, 2 de julio de 2016

"Matriz ( + - y / ) en NetBeans"

Suma de Matrices


La suma de matrices solo se puede realizar entre matrices de la misma dimensión, es decir, las mismas filas y las mismas columnas, por consiguiente la matriz resultante tiene las mismas dimensiones. La suma se efectúa en cada uno de los elementos correspondiente a cada matriz en su posición actual, es decir, se sumará la posición mat1[0,0] con la posición mat2[0,0] y el resultado se guardara en mat3[0,0].
suma de matrices

Deberemos declarar tres matrices de m x n (recordar que las 3 matrices deben tener el mismo número de filas y columnas así que se pedirá sólo 1 sola vez al usuario) .
int filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de las matries"));
int columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de las matrices"));
int matrizA[][]=new int[filas][columnas];
int matrizB[][]=new int[filas][columnas];
int matrizRes[][]=new int[filas][columnas];
Muy bien, ahora pedimos guardar los datos tanto en la matrizA como en matrizB.


Nota: No hay necesidad de pedir datos a matrizRes ya que se generaran los datos con la suma.
//Escribir datos en la matrizA
System.out.println("Datos de la Matriz A:");
for(int i=0;i<filas;i++){
        for(int j=0;j<columnas;j++){
                matrizA[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
                System.out.print(matrizA[i][j]+" ");
        }
        System.out.println();
}

//Escribir datos en la matrizB
System.out.println("Datos de la Matriz B:");
for(int i=0;i<filas;i++){
        for(int j=0;j<columnas;j++){
                matrizB[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz B"));                            
                System.out.print(matrizB[i][j]+" ");
        }
        System.out.println();
}

Por último realizamos la suma y la guardamos en matrizRes.
System.out.println("Suma de las dos matrices:");
for(int i=0;i<filas;i++){
        for(int j=0;j<columnas;j++){
                matrizRes[i][j]=matrizA[i][j]+matrizB[i][j];                            
                System.out.print(matrizRes[i][j]+" ");
        }
        System.out.println();
}

El resultado sera el siguiente:  

Resta de Matrices


La resta de matrices es similar a la suma, se cumplen las mismas reglas de que deben tener las mismas dimensiones, a diferencia de la suma, ésta se deben de restar, Ejemplo.
resta de matrices

El código es el mismo que la suma a excepción de que se resta en lugar de sumar.
System.out.println("Resta de las dos matrices:");
for(int i=0;i<filas;i++){
        for(int j=0;j<columnas;j++){
                matrizRes[i][j]=matrizA[i][j]-matrizB[i][j];                            
                System.out.print(matrizRes[i][j]+" ");
        }
        System.out.println();
}

 el resultado es el siguiente:  
resultado resta

Multiplicación de Matrices

En la multiplicación de matrices cambia la forma de seguir las reglas, en esta ocasión se requiere que el número de columnas de la primera matriz sea igual al número de filas de la segunda matriz, o viceversa. En esta operación se multiplicará una matriz m x n por una matriz n x r, y la matriz resultante es de dimensión m x r.


Si tuviéramos una matriz de 2x3 y una de 3x2 la matriz resultante sería una matriz de 2x2.
A diferencia de la suma o de la resta, la operación de la multiplicación no es posición por posición, se realiza de la siguiente manera:

1.- Se toma la primera fila de la primera matriz y la primera columna de la segunda matriz, lo que se hace es multiplicar cada posición de la fila por cada posición de la columna, y sumar los valores resultantes de esas multiplicaciones.


2.- El resultado de esa suma se coloca en la primera posición de la matriz resultante.
(3*3) + (7*1) + (5*4) = 36


3.- En caso de haber mas filas se toma la segunda fila, pero se sigue multiplicando por la primera columna, se hace la respectiva multiplicación y suma de valores resultantes, el resultado se guarda en la matriz resultante en la posición correspondiente.  

4.- Si hay más columnas se repite el proceso desde el punto 1, a diferencia que las multiplicaciones se harán sobre la columna 2 de la segunda matriz.
Hasta tener nuestra matriz resultante.

Para el código en java, en esta ocasión si es necesario pedir las filas y columnas en las dos matrices, y crear una tercera matriz con las filas de la primera matriz y las columnas de la segunda matriz.
int filasA=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas para la matriz A"));
int columnasA=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas para la matriz A"));
int matA[][]=new int[filasA][columnasA];
                
int filasB=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas para la matriz B"));
int columnasB=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas para la matriz B"));
int matB[][]=new int[filasB][columnasB];
                
int matRes[][]=new int[filasA][columnasB];

Se piden los datos para guardar en las matrices como los hemos pedido anteriormente.
//Escribir datos en la matrizA
System.out.println("Datos de la Matriz A:");
for(int i=0;i<filasA;i++){
        for(int j=0;j<columnasA;j++){
                matA[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
                System.out.print(matA[i][j]+" ");
        }
        System.out.println();
}

//Escribir datos en la matrizB
System.out.println("Datos de la Matriz B:");
for(int i=0;i<filasB;i++){
        for(int j=0;j<columnasB;j++){
                matB[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz B"));                               
                System.out.print(matB[i][j]+" ");
        }
        System.out.println();
}

Continuamos con el algoritmo para realizar la multiplicación ya explicada anteriormente.
System.out.println("Resultado: ");
                    
for ( int i = 0; i < filasA; i++){ 
        for ( int j = 0; j < columnasB; j++){
                for ( int k = 0; k < columnasA; k++ ){ //puede ser columnasA o filasB ya que deben ser iguales
                        matRes[ i ][j ] += matA[i][k]*matB[k][j];
                }
                System.out.print(matRes[i][j]+" ");
        }
        System.out.println();
}

Actividades en "NetBeans" Caratula

Como programara una "Caratula"


Descripción:

Abrimos NetBeans y creamos un nuevo proyecto: una aplicación java  y  clic en siguiente.
programacion java tabascoA la segunda ventana le dan ’siguiente’ y en la tercera escriben el nombre del proyecto que se creará (yo le llamé  ‘login’)  y desmarcamos la casilla crear clase principal.  Clic en finalizar.
programacion con ide netbeansUna vez creado nuestro proyecto notaran que no tenemos archivos así que crearemos un paquete de archivos llamado ‘login’
paquete jave netbeans
… y ya dentro de nuestro paquete se creará el form principal al que evidentemente llamé  ‘principal’
form principal java
El árbol de nuestro proyecto debe quedar más o menos así:
La idea central de la práctica es no dejar que el usuario pueda acceder al sistema sin antes estar debidamente identificado;  Lo primero que haremos es agregar un componente Jpanel al formulario ‘principal’
jpanel con netbeans, programacion java
.. Y dentro del panel pueden agregar cualquier contenido,  en el inspector de componentes podrás ver los elementos que has insertado al formulario
inspector netbeans
Ahora vamos a correr nuestro programa para ver su apariencia,  va a aparecer una pantalla indicándonos que el proyecto no cuenta con una clase principal y nos pregunta si queremos hacer que este form sea la clase principal,  clic en ok.
ejecución de form java
Nos toca ahora hacer la ventanita que nos pedirá el nombre de usuario y contraseña, pare ello vamos a agregar al formulario un controldialog
componeten dialog netbeans
Una vez agregado el control se podrá notar que…  nada! no se notará nada, y es que el control no es visible desde form pero si lo podemos ver en el inspector de componentes y si le damos doble clic al elemento entonces lo haremos visible para poder trabajar con él.  Le cambiaré el nombre de variable por dialogo.
Ahora, una vez en el Jdialog hay que agregar un Text Field , un password Field y un botón para dejar el Jdialog más o menos así:
Si corres el programa nuevamente notaras que el dialogo no es visible ya que es mediante programación que lograremos eso. Vamos al  método constructor del formulario, diríjase a la pestaña que está a la derecha del inspector y de doble clic en el método constructor.
programar con java
Vamos a agregar algo de código en el método constructor que te debe quedar de la siguiente manera ( el método initComponents es creado por NetBeans, no lo toques):
      public principal() {
        initComponents();
        dialogo.setSize(350, 220);
        dialogo.setLocationRelativeTo(this);
        dialogo.setTitle("Inicio de Sesión");
        dialogo.setVisible(true);
    }
Resumiendo, la funciónsetSize indica el ancho y largo del dialogo,  consetLocationRelativeTo(this)posicionamos el dialogo en el centro de la pantalla,setTitle designa el titulo del dialogo y setVisiblemuestra el dialogo. Ahora corre el programa y veras el dialogo detrás del formulario principal.
Vamos a desaparecer el form principal para que solo se vea el dialogo de inicio de sesión, vaya al método principal del formulario
y la propiedad true de esta línea cámbiala a false,luego corre el form y solo veras el dialogo.
new principal().setVisible(false);
Sin embargo si cerramos el dialogo el programa sigue corriendo aunque no lo veamos, es por ello que vamos programar la acción que realizará el dialogo al cerrarse. Seleccione de nuevo el componente dialog y en el panel de propiedades en la pestaña eventos seleccionamos el evento windowClosing y automáticamente nos creara el código del evento
Al que solo tendrán que agregar esta sencilla líneaSystem.exit(0); de tal modo que el código de ese evento nos quedara así:
    private void dialogoWindowClosing(java.awt.event.WindowEvent evt) {
        System.exit(0);
    }
Con esto al momento de cerrar el dialog, el programa entero se cierra y dejamos de consumir recursos en nuestra maquina.  Ya casi terminamos, ahora solo nos toca la validación del login. Vamos a hacer visible de nuevo el componente dialogo y cambiamos los nombres de las variables del TextField y el PasswordField por estos:  tusuario y tpassword
Ahora damos doble clic en el botón iniciar sesión para ver el código del ActionPerformed y le agregamos este código:
 String usuario=tusuario.getText();
 String password=tpassword.getText();
 if((usuario.isEmpty())||(password.isEmpty()))
 {
 JOptionPane.showMessageDialog(null, "Ingrese su nombre de usuario y contraseña");
 }
 else
 {
 this.setVisible(true);
 dialogo.setVisible(false);
 }
En esta lección no veremos nada de acceso a datos así que solo haremos una validación simple;  El código anterior nos indica que si el usuario no rellena los campos de usuario y contraseña le aparecerá un mensaje de error haciéndoselo saber pero si  rellenó los dos campos entonces el form principal de hará visible y el dialogo desaparecerá.
Una cosa más, para hacer uso del JOptionPane hay que importar la libreríajavax.swing.JOptionPanede otro modo el programa no va a correr.

Selección para Java

"Seleccion case/switch"

← Sentencia if-elseSentencia switch
Operador if-else →
La sentencia switch se encarga de estructurar una selección múltiple. Al contrario del enunciado if-else que sólo podemos indicar dos alternativas, maneja un número finito de posibilidades. La estructura general del enunciado switch es la siguiente:
 switch( expresión ) {
 case constante1:
      sentencia1;
      ...
      break;
      ...
 case constanteN:
      sentenciaN;
      ...
      break;
 default:
      sentencia;
      ...
      break
 }
El valor de la expresión y de las constantes tiene que ser de tipo char, byte, short o int. No hay lugar para booleanos, reales ni long porque, en la ejecución, todos los valores que incorporamos se transforman en valores de tipo int.

¿Que ocurre si cambiamos la variable op por algún carácter distinto a los especificados? Entra en juego la alternativa default y todas las setencias que le siguen. En este caso imprime por pantalla el mensaje "error". Si nos olvidamos de incorporar esta alternativa, no pasa nada. Ninguna sentencia dentro de la estructura switch se ejecutará.
Ya que hablamos de default, es conveniente mencionar que no es necesario que quede relegado al final de la estructura. Podemos situarla al comienzo , en el medio, en definitiva, en donde nos quede mas útil según la lógica que apliquemos o donde queramos.
     switch ( op ) {
     default :
          System.out.println("error");
          break;
     case '+':
          System.out.println( a + b );
          break;
           ...
En el ejemplo presentado, funciona de la misma manera un default al principio. Obviamente no debe existir mas de una alternativa default.
Las sentencias break son opcionales. Se utilizan con el propósito de separar las alternativas. Pero fieles a nuestro estilo de meternos en problemas decidimos que algunos break deben desaparecer. Probemos que ocurre con este código:
     switch ( op ) {
     case '+':
          System.out.println( a + b );
     case '-':
          System.out.println( a - b );
          break;
           ...
Es el mismo que el original, solo "olvidamos" de agregarle un break al final de la alternativa suma. Si cambiamos el valor de op por el carácter '+' y ejecutamos el programa, nos responde de esta manera:

  El resultado es : 2
  0



Comparacion y Seleccion de Java

"Comparación If-Else"

← Estructuras de selecciónSentencia if-elseSentencia switch →
Para una división de enteros. Utilizando variables y operadores. Podemos establecer una condición que permita la división para todos los números y que rechace cualquier divisor con cara de cero. Disponemos de dos opciones : realizar o no la división. También una condición: el divisor sea distinto de cero. Esto se parece mucho a una selección simple.
La estructura de selección simple en Java se realiza mediante la sentencia if(si, en ingles). La sintaxis es la siguiente :
if (condición) sentencia;    
La condición es una expresión booleana. La sentencia se ejecuta solamente si la expresión booleana es verdadera.
Retomando el problema de la división, incorporamos una estructura de selección para realizar la operación libre de ceros.
public class DivisionSegura {
   public static void main(String args[]){
          int x = 12;
          int y = 0;
          int z = 0;
          if( y !=0 ) z = x / y;
          System.out.println("El resultado es : " + z);
   }
}
En el programa, la variable x tiene el valor del dividendo, la y el divisor y la z el cociente. La condición es una expresión que arroja un valor booleano. En este caso se utiliza un operador relacional que verifica si y es distinto de 0. Si esta condición se cumple realiza la división. En caso contrario se saltea la división y solo imprime el valor de z, que hemos inicializado convenientemente antes de la operación.
¿Qué ocurre si la condición no se cumple? En este caso nada. Podemos agregar una serie de instrucciones que se ejecutarán solo si la condición no se cumple. Para esto tendremos que agregar la sentencia else. La estructura de selección quedará así:
if (condición) sentencia 1; 
else sentencia 2;

Si la condición es verdadera se ejecuta la sentencia 1 en caso contrario se ejecuta la sentencia 2. Ambas sentencias nunca se ejecutarán al mismo tiempo, son excluyentes.
Ahora ampliemos el programa para mostrar una advertencia en el caso que se encuentre cara a cara con un cero siniestro.
public class DivisionSegura {
   public static void main(String args[]){
          int x = 12;
          int y = 0;
          int z = 0;
          if( y !=0 ) z = x / y;
          else System.out.println("Atención! se pretende dividir por 0");
          System.out.println("El resultado es : " + z);
   }
}
El programa nos quedó mas completo. Con la cláusula else incluimos otra alternativa de acción. Pero algo anda suelto. Este programa siempre muestra un resultado, se cumpla o no la condición. El mensaje por pantalla no está incluido en la estructura de selección. Tendremos que colocarlo dentro del sector de sentencias que se ejecutarán cuando la condición sea verdadera. Para agrupar las sentencias se utilizan las llaves ( { } ) Indicarán el inicio y el fin de un bloque de sentencias.
Probemos como queda con un bloque
public class DivisionSegura {
   public static void main(String args[]){
          int x = 12;
          int y = 2;
          int z = 0;
          if( y !=0 ) {
              z = x / y;
              System.out.println("El resultado es : " + z);
          }  else   {
               System.out.println("Atención! se pretende dividir por 0");
          }
   }
}
Las buenas prácticas en defensa de un código mantenible han dictaminado que utilicemos las llaves en todo momento, aún en el caso que utilicemos una sola sentencia.
if (condición) {  
     sentencia;
}  else { 
        sentencia; 
}
Lamentablemente no siempre nos encontraremos con condiciones tan sencillas. Muchas veces tendremos que recurrir a proposiciones compuestas para formar una condición. Para ello podemos recurrir a operadores relacionales o lógicos. Recuerden que siempre debe dar como resultado un valor booleano.
Supongamos que deseamos saber si un año es bisiesto. Sabemos que debe ser múltiplo de 4. Para esto tendremos que verificar si el módulo es igual a cero.
año % 4 == 0
Pero no debe ser múltiplo de 100.
( año % 4 == 0 ) && ( año % 100 != 0 )
A menos que sea múltiplo de 400.
((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 == 0 ))
Formamos una proposición compuesta con conectores lógicos. Ahora vamos a incorporarlo en una estructura se selección.
if ((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 == 0 )) {
    System.out.println("Es bisiesto");
} else { 
       System.out.println("No es bisiesto");
}
Los conectores lógicos nos permiten simplificar la estructura. Sin ellos nos veríamos en la necesidad de anidar las sentencias. Veamos que ocurre si en elejemplo anterior descartamos el AND y el OR.
if ( x % 4 == 0 ) {
    if ( x % 100 == 0 ) {
        if ( x % 400 == 0 ) {
            System.out.println("Es bisiesto");
        } else {
               System.out.println("No es bisiesto");
        }
    } else  {
             System.out.println("Es bisiesto");
    }
}  else {
         System.out.println("No es bisiesto");
}


Programacion y Lenguaje de Java

"Programacion para Do-While"


← Sentencia whileSentencia do-whileSentencia for →
La sentencia de iteración do-while es de tipo posprueba. Primero realiza las acciones luego pregunta. La sintaxis es la siguiente:
 do sentencia while ( condición );
Observamos que es como un while pero al revés. Primeramente se ejecuta la sentencia y luego evalúa la condición. Si la expresión de la condición es verdadera vuelve a dar un ciclo. De lo contrario, termina. Esto nos garantiza que la sentencia se ejecute al menos una vez.
 do System.out.println("Lo veras una vez");
 while ( false );
Resulta útil para los casos en donde tendremos que realizar ciertas acciones antes de verificar una condición.
Realicemos un programa que cuente la cantidad de dígitos que posee un número. Para ello tendremos que dividir por diez el número que nos han dado, hasta que el resultado se vuelva cero. Entonces recurrimos al while para realice los ciclos necesarios.
public class CuentaDigitos{
   public static void main(String args[]){
      int número = 4557888;
      int dígitos = 0;
      while ( número > 0 ) {
          número /=10;
          dígitos++;
      }
      System.out.println(dígitos);
   }
}

¿Qué ocurre si el número que nos dan es el cero? El resultado nos dará cero. Obviamente es erróneo, debería devolver un dígito. Pero no entra en el ciclo debido a que de entrada no satisface la condición. Podríamos implementar una solución "ad hoc".
 número /=10;
 dígitos++;
 while ( número > 0 ) {
       número /=10;
       dígitos++;
 }

public class CuentaDigitos{
   public static void main(String args[]){
      int número = 4557888;
      int dígitos = 0;
      do {
         número /=10;
         dígitos++;
      }
      while ( número > 0 );
      System.out.println(dígitos);
   }
}

Programacion y Caracteristicas del Lenguaje Java

"Programacion para FOR"

La sentencia for me permite repetir un ciclo n veces, en donde se debe determinar el valor inicial y cuantas veces se repetira.
Ejemplo: 
for ( int factor = 1; factor <= 9; factor ++ ) {
      System.out.println("3 x " + factor + " = " + 3*factor );
}

sintaxis
for({valor inicial};{condición de termino};{factor de incremento del valor inicial}){
  //acá va lo que se repetirá n veces de acuerdo a la condición de termino
}

Bucle infinito: no hay control, entonces no se detiene
 for ( ;;){}
Operador coma :
 for ( int k=1, j=10 ;k < j ;k++ ,j-- ){
                 System.out.println(k + " " + j);
             }.   
"Programacion de While"
La sentencia while es la más sencilla de las estructuras de iteración. La iteración continuará hasta que su condición sea falsa.
 while ( condición ) sentencia ;
La condición tiene que tomar un valor booleano (verdadero o falso). Si este valor es verdadero, se ejecutará la sentencia. Concluida esta acción se vuelve a evaluar la condición. Proseguirán los ciclos hasta que la condición no cambie a falso.
Esta es una estructura de iteración preprueba, es decir primero se evalúa la condición antes de realizar cualquier acción. Si de entrada la condición es falsa nunca ejecutará el conjunto de sentencias.
  int n = 0;
  while ( n > 0 ) System.out.println("Esto nunca lo verás");
Dentro del conjunto de sentencia en el que el supuesto o dicho controla, debe existir alguna que cambie el valor de la condición que se está evaluando.
   boolean prueba = true;
   while ( prueba ) {
         System.out.println("Esto lo verás una vez");
         prueba = false;
   }
Entraríamos en un ciclo infinito si nunca se modifica la condición y permanece verdadera.
   boolean prueba = true;
   while ( prueba ) {
         System.out.println("Esto lo verás muchas veces");
   }
Generalmente esta estructura se utiliza en situaciones en donde desconocemos la cantidad de ciclos que se deben ejecutar para producir un resultado. Mostraremos como se utiliza en estas circunstancias con el ejemplo de pase a binario, mostrado en el capítulo anterior.
Teníamos que transformar un número decimal a binario. El programa en java nos queda de esta manera:
 public class Dec2Bin{
    public static void main(String args[]){
       int decimal = 252222;
       String binario = "";
       while ( decimal > 0 ) {
         binario = decimal % 2 + binario;
         decimal /= 2;
       }
       System.out.println(binario);   
    }
 }
Como no sabemos de antemano cuantas vueltas debe dar, simplemente esperamos que el resultado de las divisiones sucesivas sea igual a cero.
También se pueden realizar ciclos con while en donde ya conocemos, antes de entrar en la estructura, cuantas vueltas debe dar para terminar. Para esto nos auxiliamos con un contador de vueltas. Previamente tiene que inicializarse antes de ingresar al ciclo. Luego en cada vuelta se modificara según la lógica del algoritmo.
Realicemos el programa que despliegue por pantalla cinco líneas de caracteres.
 public class Cuadrado{
    public static void main(String args[]){
       int contador = 1;
       while ( contador <= 5 ) {
          System.out.println("*****\n");
          contador++;
       }
    }
 }
En este algoritmo, inicializamos el contador a 1 y luego en cada ciclo se incrementa. La condición de corte tiene como objetivo no permitir mas vueltas si el contador superó el valor 5.