jueves, 17 de octubre de 2013

INTRODUCCIÓN

Hola compañeros de batalla del aprendizaje de la programación, trataremos de ir aprendiendo juntos.


Ojo: Este blog es sólo para Supertorpes, que nadie que sepa programar se sienta aludido si simplifico demasiado, etc. Es que casi todos los manuales de java que empiezan de cero, son infumables para los que somos "Supertorpes".


Enhorabuena: el hecho de haber llegado hasta aquí ya implica que aprenderás java en mayor o menor medida.


Nota: No te asustes por las palabras y los jaleos que son para ti todos estos términos informáticos, realmente el problema no eres tú, es que no te han enseñado despacito y correctamente. Todo se puede aprender de forma sencilla si te lo explican clarito y llano.


En la columna de la derecha ves las entradas, por favor pincha en "Comenzamos" .

Si queréis hacerme algún comentario, por favor escribidme a juanmaqueta@gmail.com.

Un saludo, mucho ánimo y buen humor.

9. INTRODUCIR DATOS POR TECLADO.

Aunque ya se ha utilizado en algunos ejercicios anteriores, voy a explicar con tres ejemplos, como introducir datos por teclado. 
Así si por ejemplo queremos calcular el área de un  círculo, primero el ordenador me diga: dime el radio del círculo y yo le escriba 7 y con ese dato me calcule el área.

1. Introducir por teclado un NÚMERO entero, es decir un número sin "cachos", osea que no sea decimal: -23, 17 por ejemplo.
Es el caso que más vas a necesitar para hacer programas de java básicos que normalmente son cuentas a realizar con números, tales como sumar, dividir, etc.

import java.util.Scanner;    //hay que importar la clase scanner para poder introducir datos por teclado. Gracias a dios la clase Scanner la ha creado otra persona, nosotros nos aprovechamos de ella.


class LeerInt{  //nombre de la clase, es decir del programa, llámalo como quieras. 
    
    public static void main(String[]args){   //hay que ponerlo siempre.
        int A=0;  //creamos las dos variables que vamos a leer, dos números enteros, A y B.
        int B=0;
        
        Scanner sc=new Scanner(System.in); //esto es necesario para introducir el valor de A.
        System.out.println("Introduce el primer número: ");
        A=sc.nextInt(); 

        System.out.println("Introduce el segundo número: "); //esto es necesario para introducir el valor de A.
        B=sc.nextInt();  



        System.out.println("Los números introducidos son: "+ A+" y"+B); //muestra el resultado.
            
        System.out.println("*************PROGRAMA SECUENCIAL 1 LEER INT*************** ");//de aquí para abajo es para que quede más bonito.
                
        System.out.println("El valor introducido de A es: "+ A);
        System.out.println("El valor introducido de B es: "+ B);
             
              
        System.out.println("*******************************************************");
        System.out.println("FIN DE PROGRAMA");
        System.out.println("*******************************************************");

    }
}

2. Introducir por teclado un NOMBRE, es lo mismo que String, que es lo mismo que una cadena de caracteres, como sería por ejemplo pepito, que es una cadena formada por la p, la e, la p, la i, la t y la o.
import java.util.Scanner; //igual que antes.


class LeerString{    //igual que antes.
    
    public static void main(String[]args){  //igual que antes.
        String cadena;  //creo una variable tipo String (ojo hay que poner la S con mayúsculas) que vamos a llamar cadena.
                
        System.out.println("*************PROGRAMA SECUENCIAL 2 LEER STRING*************** ");
       
        
        Scanner sc=new Scanner(System.in);   //igual que antes.
        System.out.println("Introduce tu nombre: ");  //introduce tu nombre, por ejemplo pepito.
       
        cadena=sc.nextLine();   //capta lo que escribo por teclado y lo introduzco en la variable cadena.
        
        System.out.println("El nombre introducido es: "+ cadena);   //muestra  el nombre introducido dentro de la variable cadena, es decir muestra "pepito".
             
              
        System.out.println("*******************************************************");
        System.out.println("FIN DE PROGRAMA");
        System.out.println("*******************************************************");

    }
}

2. Introducir por teclado un caracter (Char), por ejemplo UNA LETRA  "p". Ojo en este caso, varía un poco, hay que añadir una cosa nueva.

class LeerChar{
    
    public static void main(String[]args)throws IOException{  //en este caso hay que añadir throws IOException para que funcione.
     
   char a;
                             
            System.out.print("Introduce el primer caracter: ");
             a=(char)System.in.read(); //lee un sólo caracter y lo convierte en char y el resultado se lo asigna a c, ojo es necesario poner IOException
        
        System.out.println("el caracter o letra que has introducido es: "+a);
     }
}


Con estos tres ejemplos ya siempre que haga un programilla en java, puedo copiar el código para que me pida las variables por teclado.

8. MAS EJEMPLOS BÁSICOS MEZCLADOS

1. Introduce dos números enteros por teclado y divídelos, el resultado debe tener decimales.
Nota: la dificultad es que cuando dividimos en java (/), nos devuelva el resultado entero. Existe otra operación que se llama resto (%) y lo que hace es devolvernos el resto de la división. Así que compaginando ambas y con un poco de imaginación o ayuda de google se puede hacer el ejercicio.

import java.util.Scanner; //vimos que era necesario importarse esta clase para poder introducir (escanear), números por pantalla.

class DivisionInt{    //nombre que le damos al programilla, puedes poner el que quieras.
    
    public static void main(String[]args){  //recuerda siempre se pone esto para empezar.
        int A=0;   //creo una variable entera y de momento le doy valor 0, luego cambiará este valor. Es por dar un valor inicial, podías haber puesto cualquier otro entero.
        int B=0; //creo varialble entera llamada B y la inicializo con valor 0.
        
        Scanner sc=new Scanner(System.in);
        System.out.println("Introduce el primer número: ");
        A=sc.nextInt();  //recuerda que es para que me pida el valor de A en pantalla y lo introduzca por teclado.

        System.out.println("Introduce el segundo número: ");
        B=sc.nextInt();  //igual para el valor B.
        
        if(B!=0 ) //Si B es diferente de cero haz lo de abajo (la división)
            System.out.println(A+ "/"+ B+ "="+(A/B)+","+((A%B)*10/B)); //lo que va entre comillas es para que lo pinte en pantalla de forma literal,los símbolos + son para que haga más cosas y el resto son operaciones. Si te das cuenta no hace más que dividir A/B, luego dibujar una coma y después de la coma coger el resto y multiplicarlo por 10 y dividirlo entre B, que aunque parezca muy raro es lo que hacemos en una división normal. Prueba por ejemplo con 17 entre 3 y verás que sale bien.


        else    //sino, es decir B=0, mal asunto, porque no se puede dividir.
            System.out.println("No se puede dividir entre cero");
            
           
  }
}


2. Vamos a poner un condicional. Dada un número (entero), dime si es positivo o negativo, si es para o impar, si es múltiplo de 5 y de 10 y si es mayor que 100.

class Condicional{      //nombre del programa, pon el que quieras.
    
    public static void main(String[]args){     //siempre hay que poner esta línea.
       
         int C=6;     //creación de la variable, se inicia con valor 6, luego puedo cambiarla.
             
        System.out.println("*************PROGRAMA BASICO 7 CONDICIONAL*************** ");     //para que quede bonito.
        System.out.println("VARIABLES: ");     //para que quede bonito.
        
        System.out.println("C= "+C+ "; ");     //imprime en pantalla el valor de C y luego un ;
        System.out.println((C>=0)? "ES POSITIVO " : "ES NEGATIVO");     //dice si C>0 imprime "es positivo" y sino imprime "es negativo".
        System.out.println((C%2==0)? "ES PAR " : "ES IMPAR");     //si el resto de dividir C entre dos es cero imprime es par, sino imprime es impar.
        System.out.println((C%5==0)? "ES MÚLTIPLO DE 5 " : "NO ES ES MÚLTIPLO DE 5");     //Si el resto de dividir entre cinco es cero imprime "es múltiple de cinco", sino imprime "no lo es".
        System.out.println((C%10==0)? "ES MÚLTIPLO DE 10 " : "NO ES ES MÚLTIPLO DE 10");     //igual con el 10.
        System.out.println((C-100>=0)? "ES MAYOR O IGUAL QUE 100" : "ES MAYOR O IGUAL QUE 100");     //igual para saber si es mayor que 100.
             
              
        System.out.println("*******************************************************");     //esto es para que quede bonito.
        System.out.println("FIN DE PROGRAMA");
        System.out.println("*******************************************************");

    }
}


3. Para que aprendamos definitivamente a introducir datos por teclado. 
Haz un programa que te pida por teclado la hora, los minutos y los segundos y luego te imprima en pantalla el resultado, todo seguido.
Nota: ten en cuenta que no puede haber más de 24 horas y 60 segundos o minutos.
 Es un poco largo y el resultado no es muy espectacular, pero ayudará a afianzar el tema de introducir datos por teclado. Lo comentaré poco, pues ya hemos hecho cosas parecidas.


import java.util.Scanner;         //es necesario importar esta clase ya hecha.


class Hora{     //nombre del programa, que es lo mismo que clase.
    
    public static void main(String[]args){
        int h=0;        //creo las variables y les doy valor inicial.
        int m=0;
        int s=0;
        
        Scanner sc=new Scanner(System.in);     //para introducir las horas por teclado.
        
        System.out.println("Introduce las horas: ");
        h=sc.nextInt(); 
        if(h>=0){
            if(h>24){     //hay tener en cuenta que no valen horas negativas ni mayores de 24.
                System.out.println("Error formato de horas (0-24)");
                System.out.println("Introduce las horas: ");
                h=sc.nextInt(); 
            
            }
        }
        else{
                System.out.println("Error no existen horas negativas");
                System.out.println("Introduce las horas: ");
                h=sc.nextInt(); 
            }
        
        
        System.out.println("Introduce los minutos: ");
        m=sc.nextInt(); 
        if(m>=0){
            if(m>60){     //hay tener en cuenta que no existen minutos negativos ni mayores de 60.
             System.out.println("Error formato de minutos (0-60)");
             System.out.println("Introduce los minutos: ");
             m=sc.nextInt(); 
            }
        }
        else{
             System.out.println("Error no existe minutos negativos");
             System.out.println("Introduce los minutos: ");
             m=sc.nextInt();
            }
       
        
        System.out.println("Introduce los segundos: ");
        s=sc.nextInt(); 
          if(s>=0){
            if(s>60){     //lo mismo con los segundos que con los minutos.
                System.out.println("Error formato de segundos (0-60)");
                System.out.println("Introduce los segundos: ");
                s=sc.nextInt(); 
            }
          }
          else{
                System.out.println("Error no existen segundos negativos");
                System.out.println("Introduce los segundos: ");
                s=sc.nextInt(); 
          }
       
             //con esta sentencia que sigue, se muestra el resultado en pantalla.
        System.out.println("Son las "+h+" horas,"+m+" minutos,"+s+" segundos.");
        
    }        

}

martes, 15 de octubre de 2013

7. OTROS EJEMPLOS BÁSICOS MEZCLADOS


Ahora os escribiré ejemplos básicos con diferentes dificultades, si no sabéis hacer algo, miradlo en Google y si no sois capaces de realizarlo finalmente, pasad a otro ejercicio. Una vez que hagáis un ejercicio podéis inventaros otros, cambiando pequeñas cosas  y tratar de realizarlos



1. Este es un ejemplo más complejo, para que veas que se pueden hacer más cosas.
Se denomina Bart Simpon. Consiste en lo que le manda la profesora a Bart :escribe 200 veces "No volveré a meter sapos en el bolsillo de la profesora".
Sin un programa Bart tendría que escribirlo 200 veces, con java sólo una, el resto lo hace el ordenador.

class BartSimpon{
    public static void main(String[]args){      
        int contador=1;                     //la variable contador valdrá 1                
           while(contador<200){  //mientras contador valga 1 hasta que valga 200, el ordenador hara lo que le mande.
                System.out.println(" No volveré a meter sapos en el bolsillo de la profesora"); //le he mandado imprimir esa frase.
                contador++;    // incremento contador en una unidad. Es decir de 1 a 2.
           }
     }
}

//ojo, no te olvides de darle a Run file para arrancar el programa, sino no verás el resultado.
//recuerda que no debes escribir lo que aparezca después de el símbolo //, son comentarios para que tú lo comprendas.


2. Crear una variable entera que valga 5, otra decimal que valga 4.56 y un carácter que valga 'a', e imprimir en pantalla estas variables, además de el resultado de sumar y restar las variables numéricas.

 class mezclados2{
    
    public static void main(String[]args){
        
        int N=5;                   //creo variable entera que valga 5.
        double A=4.56;        //creo variable decimal que valga 4.56
        char C='a';               //creo una variable carácter que valga a, ojo tiene que llevar comillas simples (').
        
        System.out.println("*************PROGRAMA DE CALCLULO BASICO2*************** ");  //esto es para que quede más bonito.
        System.out.println("****VARIABLES: ");  //esto también hace que quede más bonito.
        
        System.out.println("N= "+ N);  //lo que se pone entre comillas es lo que quiero que me imprima por pantalla al pie de la letra, luego se añade un + (que quiere decir que quiero añadir más cosas) y luego lo que valga la varialbe N (es decir 5). El resultado sería: N=5
        System.out.println("A= "+ A);  //lo mismo con A.
        System.out.println("C= "+ C);//lo mismo con C.
        
        System.out.println("****CÁLCULOS: ");// es para que quede bonito.
        System.out.println("N+A= "+ (N+A));    // es para que me ponta N+A= y luego el resultado de sumar N+A.
        System.out.println("A-N= "+ (A-N));     //igual pero para A-N.
        System.out.println("C= "+ C);               // ya lo hemos visto.
        System.out.println("*****FIN DE PROGRAMA"); //para que quede bonito.
    }
}


3. Crear una variable entera N que valga 17 e imprimir en pantalla el valor de N, de N+77, N+3 y de N al cuadrado. Cambia el valor de N y verás el resultado.

class mezclados3{
    
    public static void main(String[]args){
        int N=17;
                
        System.out.println("*************PROGRAMA  BASICO 3*************** ");
        System.out.println("VARIABLES: ");
        System.out.println("N= "+ N);
               
        System.out.println("*******************************************************");
        System.out.println("CÁLCULOS");  
        System.out.println("N+77= "+ (N+77));
        System.out.println("N+3= "+ (N+3));
        System.out.println("N*N= "+ (N*N));
        
        System.out.println("*******************************************************");
        System.out.println("FIN DE PROGRAMA");

    }

}

4. Crea 4 variables enteras: A1,B1,C1,D1, con valores: 1,2,3 y 4 respectivamente. Imprime (en pantalla) el valor de cada una de ellas y además imprime que A2= al valor de A1; que B2= al valor de C1; que C2= al valor de A! y que D2= al valor de B1. Cambia diferentes valores y variables y mira a ver que sucede.

class mezclados4{
    
    public static void main(String[]args){
        int A1=1;
        int B1=2;
        int C1=3;
        int D1=4;
                
        System.out.println("*************PROGRAMA  BASICO 4*************** ");
        System.out.println("VARIABLES: ");
        
        System.out.print("A1= "+A1+ "; ");
        System.out.println("A2= "+ D1);
        
        System.out.print("B1= "+B1+ "; ");
        System.out.println("B2= "+ C1);
        
        System.out.print("C1= "+C1+ "; ");
        System.out.println("C2= "+ A1);
        
        System.out.print("D1= "+D1+ "; ");
        System.out.println("D2= "+ B1);
             
              
        System.out.println("*******************************************************");
        System.out.println("FIN DE PROGRAMA");
        System.out.println("*******************************************************");

    }

}

5. Crear un programa con el que se introduce el valor del radio de una circunferencia y calcula el área y el perímetro (longitud).  Este ejercicio aporta como nuevo que el ordenador te pide el valor del radio y tu se lo introduces por teclado. Realmente empezamos a comunicarnos con la máquina.

Para poder introducir datos por teclado tenemos que importarnos esta clase java. Que es un programa que ha realizado gente muy lista y de la que nos aprovechamos. Tú simplemente escribe import y luego java.util.Scanner. Ya veremos más adelante que existen infinidad de programas ya creados que se denominan clases y que los importaremos para poder utilizarlos. Sólo con poner import y el nombre de la clase haremos cosas complejas sin tener que escribir todo el código, gracias a que ha habido algún alma caritativa que lo ha escrito previamente. Es decir nos aprovechamos del trabajo de otros. Sólo debes saber que existe un lugar donde se recopilan las clases de las que nos aprovecharemos y se llama API (Application Programming Interface en inglés). Podemos ver esta API, con todos los programas que podemos utilizar y con explicaciones de como utilizarlo en la siguiente URL: http://docs.oracle.com/javase/7/docs/api/.
El problema es que es inmenso y además las explicaciones están en inglés. Ya iremos viendo poco a poco como utilizarlo a medida que nos vaya haciendo falta. Pero de momento no te preocupes más.

import java.util.Scanner; // para poder introducir datos por teclado tenemos que importarnos esta clase java. 

class Circunsferencia{
    
    public static void main(String[]args){
      double doubleR=0, doubleL=0, doubleA=0; //crea tres variables decimales, una para el radio, otra para la longitud y otra para el área.
     
      Scanner sc=new Scanner(System.in);    //crea una variable llamada sc del tipo Scanner (ya lo veremos) y le asigna el valor que introduzcamos por teclado.
      System.out.println("Introduce el Radio: "); // imprime en pantalla para que introduzcas el valor del radio.
      doubleR=sc.nextDouble(); //el valor que has introducido por teclado se ha almacenado en sc, lo transforma de decimal y lo introduce en la variable Radio.
      
      doubleL=2*Math.PI*doubleR;   // calcula la longitud, con el valor del radio.
      doubleA=Math.PI*doubleR*doubleR;// calcula el área, con el valor del radio.
      
      System.out.println("El radio es: "+doubleR+" ,la longitud: "+doubleL+ " y el área: "+doubleA);
    }  //imprime(en pantalla) el valor del radio, la longitud y el área.

}

Este ejemplo ha sido más difícil, así que lo dejaremos aquí para descansar y recuerda para introducir un número por teclado, siempre es igual:
Scanner sc=new Scanner(System.in);    //crea una variable llamada sc del tipo Scanner (ya lo veremos) y le asigna el valor que introduzcamos por teclado.
System.out.println("Introduce el Radio: "); // imprime en pantalla para que introduzcas el valor del radio.
doubleR=sc.nextDouble(); //el valor que has introducido por teclado se ha almacenado en sc, lo transforma de decimal y lo introduce en la variable Radio.