Tutorial java para principiantes parte 1

2018-01-18 11:06:39

Ejercicios básicos para inicarse en el mundo de la programación en java. Las variables tipo primitivo y objetos, crear un nuevo proyecto con netbeans y ejercicios con distintos tipos de variables.

Introducción

1) Tipo de variables

¿Qué son las variables?

En programación, una variable está formada por un espacio en el sistema de almacenaje (memoria principal de un ordenador) y un nombre simbólico (un identificador) que está asociado a dicho espacio. Ese espacio contiene una cantidad de información conocida o desconocida, es decir un valor.

Tipo de variables en java

En java basicamente hay dos tipos de variables. Las tipo primitivos y los objetos

Variables primitivas

Estas variables pueden almacenar distintos valores dependiendo del tipo que sean. Por ejemplo la variable int puede almacenar un valor numerico entero de valor medio (hasta 4 bytes o de 0 a 1000000000)

Tipos de variables primitivas
  • byte : puede contener un numero entero en el rango de -128 a 127 (ocupa 1 byte)
  • short : puede contener un numero entero en el rango de -32768 a 32767 (ocupa 2 bytes)
  • int : puede contener un numero entero grande (ocupa 4 bytes)
  • long : puede contener un numero entero muy grande (ocupa 8 bytes)
  • float : puede contener un numero con decimal simple (ocupa 4 bytes)
  • double : puede contener un numero con decimal doble (ocupa 8 bytes)
  • char : puede contener un caracter simple (ocupa 2 bytes)
  • boolean : puede contener true o false (ocupa 1 byte)
Ejemplos de creación y asignacion de las distintas variables primitivas
byte _byte = 127;
short _short = 32767;
int _int =   4512541;
long _long = 1000000000;
float _float = 1.45F;
double _double = 2.56;
char _char = 'a';
boolean _bool = true;
                
Variables tipo objeto

Dado que Java es un lenguaje de programación orientado a objetos no nos debe sorprender el hecho de que una gran cantidad de los tipos que conforman su sistema de tipos de datos sean tipos complejos (objetos que provienen de clases). La librería estándar de Java está conformada por cientos (quizás miles) de clases que representan en última instancia un tipo de dato particular. Cabe resaltar que nosotros como programadores podemos crear nuestros propios tipos de datos a partir de los que conforman el sistema propio de Java, sin embargo al ser tipos nuestros no conforman parte del estándar de java y por ende no son parte oficial del sistema de tipos del lenguaje. Una de las principales clases que conforman estos tipos complejos es la clase String, los String no son un tipo primitivo (son objetos), sin embargo está conformado por una serie (una cadena) de chars (los cuales sí son primitivos), al ser una clase como tal, posee una serie de atributos y métodos que podemos usar para manipular nuestra cadena de caracteres.

Este tipo de variables se diferencian de las anteriores por:

  • Las variables tipo objeto comienzan con mayúscula
  • Disponen de métodos (los métodos nos permite realizar modificaciones sobre ese objeto)
  • No almacenan un solo valor, sino una referencia a una zona de memoria del ordenador. Podria decirse que puede almancenar multiple valores.
Ejemplos de creación y asignacion de las distintas variables tipo objeto
Variable tipo objeto sin new
String nombre = "Hugo";
                
Variable tipo objeto con new
Scanner scanner = new Scanner(System.in);
                

Práctica con variables primitivas

1) Crear un proyecto en java y darle el nombre de practica_1

1) Ir al menú de netbeans en File / New Proyect

2) en Categories seleccionar la carpeta java y en projects seleccionar java application. A continuación presionar el botón Next

2) Modificar el nombre del proyecto (project name) por practica_1 como se indica en el enunciado. Finalmente presionar el botón Finish

2) En la clase principal main crear dos variables tipo int y asignarle el valor 100 y 50. Crear una tercera variable y asignarle la suma de las dos variables anteriores. Mostrar el resultado de la tercera variable.

public static void main(String[] args) {
    int var1 = 100;
    int var2 = 50;
    int total = var1 + var2;
    System.out.println("Total = " + total);
}
            

3) Crear una variable tipo int y asígnale el valor 200. Incrementar en 100 esta misma variable. Visualiza el resultado.

public static void main(String[] args) {
    int var1 = 200;
    var1 = var1 + 100;
    System.out.println("Total = " + var1);
}
            

4) Crear una variable tipo int y asígnale un valor, duplica su valor y visualiza el resultado.

public static void main(String[] args) {
    int var1 = 200;
    var1 = var1 * 2;
    System.out.println("Total = " + var1);
}
            

5) Crea una variable tipo int y asignale el número 80. Divide su valor por 3. Finalmente obten el módulo o resto de la división (usa el operador aritmético % de java).
Destacar que el operador % es de uso exclusivo entre enteros. 7%3 devuelve 1 ya que el resto de dividir 7 entre 3 es 1. Al valor obtenido lo denominamos módulo (en otros lenguajes en vez del símbolo % se usa la palabra clave mod) y a este operador a veces se le denomina “operador módulo”.

public static void main(String[] args) {
    int numero = 80;
    numero = numero/3;
    int modulo = numero%3;

    System.out.println("modulo: " + modulo);
}
            

6) Crea una variable tipo byte y asignale el valor de 200. Visualiza el resultado.

Dará error de compilación. Una variable tipo byte tiene un rango entre -128 y 127.

7) Resuelve: Cuantas cajas necesitamos para guardar 400 botellas de vino. Sabemos que cada caja puede contener un máximo de 8 botellas.

public static void main(String[] args) {
    int botellas = 400;
    int caja_capacidad = 8;
    int cajas_totales = botellas / caja_capacidad;
    System.out.println("Total = " + cajas_totales);
}
            

8) Crea una variable tipo char por cada volcal del abecedario. A continuación visualiza todas las vocales en una sola linea separadas por comas. Recuerda que para asignar una letra a una variable char esta debe ir entre comillas simples (char a = 'a';)

public static void main(String[] args) {
    char a = 'a';
    char e = 'e';
    char i = 'i';
    char o = 'o';
    char u = 'u';
    System.out.println("Letras: " + a + ", " + e + ", " + i + ", " + o + ", " + u);
}
            

Práctica con objeto Scanner

El objeto Scanner permite leer datos introducidos desde un teclado.

Lo primero que tendremos que hacer es importar la clase Scanner desde la libreria desde java y de la siguiente manera.

import java.util.Scanner;
                

Todas las intrucciones import se deben realizar al principio de nuestro archivo justo despues de la instrucción package como se muestra en el código siguiente.

package practica_1;
import java.util.Scanner;

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

Ya tenemos la clase Scanner importada. Ahora tendremos que declarar una variable de este tipo e instanciarla como se muestra a continuación.

Scanner scanner = new Scanner(System.in);
                

El código completo quedaría de la siguiente forma:

package practica_1;
import java.util.Scanner;

public class practica_1 {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
    }
}
                

Instanciarla ????

Que diablos es eso?. Instanciar es crear una cosa a partir de otra. Tenemos que separar tres conceptos básicos:

  • Clase
  • Objeto
  • Instancia

Imaginemos que tenemos que cocinar una tarta. Necesitaremos la receta donde se detallen los ingredientes y la descripción como se deben mezclar los ingredientes, tiempo de cocción, etc.

Esa lista de ingredientes seria la clase y la tarta ya cocinada sería el objeto. Y el proceso para llegar de la receta a la tarta sería la instancia.

Al crear el objeto tarta podremos acceder a todos sus métodos (son funciones que permiten cambiar ciertas cosas de nuestra tarta. como por ejemplo añadir mermelada como relleno).

Continuamos con Scanner para leer datos introducido por teclado.

Ahora que sabemos como se instancia (crea) un objeto a partir de una clase crearemos un objeto tipo Scanner.

Scanner scanner = new Scanner(System.in);
                

A diferencia de la clase Tarta. A Scanner entre los parentesis le hemos colocado System.in. Ya lo explicaremos más adelante. De momento solo lo ponemos en caso contrario dará un error.

Ejemplo básico. Solicitamos cuantos perros tiene el usuario y visualizamos la cantidad introducida por pantalla

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int cantidadperros = scanner.nextInt();
    System.out.println("Tienes " + cantidadperros + " perros");
}                  
                

1) Solicita la edad que tiene el usuario (utiliza System.out.println) y guarda ese valor en una variable tipo int (utiliza Scanner como en el ejemplo anterior)

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int edad = scanner.nextInt();
    System.out.println("Tienes " + edad + " años");
} 
            

2) Pregunta cuantos asignaturas tiene en el colegio y cuantas de ellas son impartidas por mujeres. Muestra la cantidad total y las cantidades para mujeres y hombres

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("¿Cuántas asignaturas tienes en tu colegio?");
    int total_asignaturas = scanner.nextInt();

    System.out.println("¿Cúantas son impartidas por mujeres?");
    int total_mujeres = scanner.nextInt();

    int total_hombres = total_asignaturas - total_mujeres;

    System.out.println("Tienes " + total_asignaturas + " asignaturas. De las cuales " + total_mujeres + " son impartidas por mujeres y " + total_hombres + " por hombres");
} 
            

3) Pregunta la edad del hermano menor y del mayor. Visualiza la edad media.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("¿Cúantos años tiene tu hermano menor?");
    int hermano_menor = scanner.nextInt();

    System.out.println("¿Cúantos años tiene tu hermano mayor?");
    int hermano_mayor = scanner.nextInt();

    int media = (hermano_mayor + hermano_menor) / 2;

    System.out.println("La edad media de tus hermanos son los " + media + " años");
} 
            

4) Pregunta la cantidad de hermanos que tiene. Visualiza la cantidad de dedos que suman todos ellos incluyendo al usuario.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("¿Cúantos hermanos tienes?");
    int total = scanner.nextInt();
    total++;
    int dedos = ((total * 2) * 2) * 5;

    System.out.println("Todos suman un total de " + dedos + " dedos");
} 
            

5) Pregunta la cantidad de perros que tiene el usuario, su vecino de arriba y el de abajo. Visualiza la media

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("¿Cúantos perros tienes?");
    int mios = scanner.nextInt();

    System.out.println("¿Cúantos perros tiene tu vecino de arriba?");
    int vecino_arriba = scanner.nextInt();

    System.out.println("¿Cúantos perros tiene tu vecino de abajo?");
    int vecino_abajo = scanner.nextInt();

    int media = (mios + vecino_arriba + vecino_abajo) / 3;
    

    System.out.println("La media de perros en tu edificio son de " + media + " perros por vivienda.");
} 
            

6) Visualiza el índice de masa muscular del usuario. Para ello tienes que solicitar su peso (en kg) y altura (en metros). La formular para calcular IMC = peso / altura2. Recuerda utilizar variables con decimales (float) para los metros y el cálculo de IMC.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("¿Cuánto pesas (en Kilogramos)?");
    int peso = scanner.nextInt();

    System.out.println("¿Cúanto mides de estatura (en metros)?");
    float altura = scanner.nextFloat();
    float imc = peso / (altura*altura);

    System.out.println("Tu indice de masa muscular es " + imc);
} 
            

Práctrica con objeto String

El objeto String permite almacenar texto. String es un objeto porque almacena muchas variables de tipo char (caracteres) y contiene métodos para tratar dichos chars.

Algunos métodos de String
  • Convertir a mayúsculas y minúsculas
  • Buscar dentro del texto una letra o palabra
  • Recortar un texto
  • Obtener la cantidad total de caracteres. Etc.

A diferencia del objeto Scanner. String no debe instanciarse y se puede utilizar como una variable de tipo primitivo. A continuación creamos un objeto tipo String y le asignamos un texto.

public static void main(String[] args) {
    String nombre = "Mi nombre es Hugo";
} 
                
¿Cómo usar un método de la clase String?

Simplemente luego de crear el objeto String escribimos el nombre del objeto seguido de un punto y a continuación se desplegarán todos sus métodos. Mira la siguiente imagen.

En este ejemplo usamos el método toUpperCase() el cual convierte todo el texto a mayúsculas.

public static void main(String[] args) {
    String nombre = "Mi nombre es Hugo";
    //el método toUpperCase() convierte todo el texto a mayúsculas
    nombre = nombre.toUpperCase();

    System.out.println(nombre);
} 
                

Concatenar texto

String nos permite concatenar texto de forma muy simple (concatenar es unir). Podemos utilizar el método concat del objeto String o simplemente usamos el operador +. Por ejemplo

public static void main(String[] args) {
    
    String texto1 = "El árbol";
    String texto2 = "es muy bonito";
    
    String frase = texto1 + texto2;
    System.out.println(frase);

    //Esto da el mismo resultado que la variable frase
    String frase2 = "El árbol" + "es muy bonito";

    //Esto otro tambien nos da el mismo resultado
    String frase3 = texto1 + "es muy bonito";

    //Esto otro tambien nos da el mismo resultado
    String frase4 = "El árbol" + texto2;
} 
            

1) Solicita el nombre del usuario. Conviertelo a mayúsculas y saluda al usuario por su nombre en pantalla

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("¿Como te llamas?");
    String nombre = scanner.nextLine();
    nombre = nombre.toUpperCase();
    
    System.out.println("Hola " + nombre);
} 
            

2) Solicita el nombre del usuario y visualiza la cantidad de caracteres que tiene su nombre. Utiliza el método length() del objeto String

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("¿Como te llamas?");
    String nombre = scanner.nextLine();
    int total = nombre.length();
    
    System.out.println("Tu nombre tiene " + total + " caracteres");
} 
            

3) Crea una variable tipo String y asignale la siguiente frase "En la palmera hay tres monos y tres tucanes". Visualiza la frase en pantalla.

  • Crea un nuevo String y reemplaza la palabra tres por cuatro (utiliza el método replace() del objeto String). Al método replace() tienes que indicarle (por parámetros *) el valor a buscar y el nuevo valor, por ejemplo replace("hola","adios").
    * Los parámetros son los distintos valores que se le pasa a un método y éstos se colocan entre los paréntesis por ejemplo nombre.replace("hugo","daniel");
    public static void main(String[] args) {
        String texto = "En la palmera hay tres monos y tres tucanes";
        System.out.println(texto);
        String texto_modificado = texto.replace("tres", "cuatro");
    
        System.out.println(texto_modificado);
    } 
                        
  • Igual que el caso anterior pero solo reemplaza la primera coincidencia (utiliza el método replaceFirst())
    public static void main(String[] args) {
        String texto = "En la palmera hay tres monos y tres tucanes";
        System.out.println(texto);
        String texto_modificado = texto.replaceFirst("tres", "cuatro");
    
        System.out.println(texto_modificado);
    } 
                        
  • Al ejercicio anterior conviertelo a mayúsculas sin necesidad de crear un nuevo string. (Concatena los métodos).
    public static void main(String[] args) {
        String texto = "En la palmera hay tres monos y tres tucanes";
        System.out.println(texto);
        String texto_modificado = texto.replaceFirst("tres", "cuatro").toUpperCase();
    
        System.out.println(texto_modificado);
    } 
                        

4) Solicita el nombre al usuario. Visualiza el nombre introducido en mayúsculas (método toUpperCase()), minúsculas (método toLowerCase()) y el número de caracteres (método length())

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Introduce tu nombre");
    String nombre = scanner.nextLine();
    System.out.println(nombre.toUpperCase());
    System.out.println(nombre.toLowerCase());
    System.out.println(nombre.length());
} 
            

5) Solicita el nombre al usuario. Crear una variable tipo char y guarda en ella el primer caracter del nombre introducido por el usuario. Utiliza el método charAt(). Lee a continuación

Un String es un conjunto de caracteres (chars)

Como hemos indicado al principio, un objeto String es un conjunto de chars. Pero la forma correcta de llamarlo es array de chars. A partir de ahora lo llamaremos así.

Un array es una agrupación de un mismo tipo. Un String contiene un array de tipo chars. Un array siempre esta ordenado comenzando la primera posición por el valor 0 como indica la siguiente imagen.

La imagen anterior muestra un String que contiene la palabra libros. La primera letra es la letra L y corresponde a la primera posición del array y esta primera posición comienza por el número 0.

Al método charAt() hay que indicarle por parámetro la posición del array que queremos obtener.

Por ejempolo si queremos obtener la letra B tendremos que indicarle que queremos la posición 2 del array. Y quedaría así:

public static void main(String[] args) {
    String palabra = "LIBROS";
    char letra = palabra.charAt(2);
} 
                

* Recuerda que un espacio en blanco también es un caracter y ocupa una posición en el array.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Introduce tu nombre");
    String nombre = scanner.nextLine();
    char letra = nombre.charAt(0);
    System.out.println(letra);
} 
            

6) Solicita el nombre al usuario. Obten la cantidad de caracteres (crea un variable tipo int y usa el método length()). Y con el método charAt() obtén la última letra del nombre introducido por el usuario y muestralo por pantalla.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Introduce tu nombre");
    String nombre = scanner.nextLine();
    int tamano = nombre.length();
    char letra = nombre.charAt(tamano-1);
    System.out.println(letra);
} 
            

7) Solicita el nombre al usuario. Obten la primera letra del nombre introducido, pero en vez de utilizar el método chartAt() utiliza el método subString() (*). Visualiza por pantalla la primera letra.
* El método subString() hay que indicarle por parámetro la posición inicial y final. Por ejemplo subString(0,5); nos devolverá desde la primera letra hasta la quinta posición.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Introduce tu nombre");
    String nombre = scanner.nextLine();
    String primera = nombre.substring(0,1);
    System.out.println(primera);
} 
            

8) Solicita el nombre al usuario. Obten la cantidad de caracteres (crea un variable tipo int y usa el método length()). Finalmente con el método subString() obtiene el último caracter y muestralo en pantalla.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Introduce tu nombre");
    String nombre = scanner.nextLine();
    int tamano = nombre.length();
    String ultimo = nombre.substring(tamano-1,tamano);
    System.out.println(ultimo);
} 
            

9) Solicita el nombre al usuario. Convierte a mayúscula la primera letra. Visualiza el nombre modificado.

run:
Introduce tu nombre
hugo
Hugo
BUILD SUCCESSFUL (total time: 4 seconds)

En este ejemplo debes utilizar solo String y lo métodos substring, toUpperCase y length

public static void main(String[] args) {
    Scanner teclado = new Scanner(System.in);
        
    System.out.println("Introduce tu nombre");
    String nombre = teclado.next();

    int tamano = nombre.length();

    String primeraLetra = nombre.substring(0,1);
    primeraLetra = primeraLetra.toUpperCase();

    String restoNombre = nombre.substring(1, tamano);

    String nombreConvertido = primeraLetra + restoNombre;

    System.out.println(nombreConvertido);
} 
            

10) Solicita el nombre al usuario. Convierte a mayúscula la primera y última letra. Visualiza el nombre modificado.

run:
Introduce tu nombre
daniel
DanieL
BUILD SUCCESSFUL (total time: 2 seconds)

En este ejemplo debes utilizar solo String y lo métodos substring, toUpperCase y length

public static void main(String[] args) {
    Scanner teclado = new Scanner(System.in);
        
    System.out.println("Introduce tu nombre");
    String nombre = teclado.next();

    int tamano = nombre.length();

    String primeraLetra = nombre.substring(0,1);
    primeraLetra = primeraLetra.toUpperCase();

    String ultimaLetra = nombre.substring(tamano-1,tamano);
    ultimaLetra = ultimaLetra.toUpperCase();

    String restoNombre = nombre.substring(1, tamano-1);

    String nombreConvertido = primeraLetra + restoNombre + ultimaLetra;

    System.out.println(nombreConvertido);
} 
            

11) Solicita el nombre al usuario y la posición del caracter que quiere convertir a mayúscula. Recuerda que la primera posición es 0

run:
Introduce tu nombre
hugo
Introducd el número del caracter a convertir a mayúscula
3
hugO
BUILD SUCCESSFUL (total time: 5 seconds)

En este ejemplo debes utilizar solo String y lo métodos substring, toUpperCase y length

public static void main(String[] args) {
    Scanner teclado = new Scanner(System.in);
        
    System.out.println("Introduce tu nombre");
    String nombre = teclado.next();

    System.out.println("Introducd el número del caracter a convertir a mayúscula");
    int posicion = teclado.nextInt();

    int tamano = nombre.length();

    String letra = nombre.substring(posicion, posicion+1);
    letra = letra.toUpperCase();

    String nombreConvertido = nombre.substring(0, posicion) + letra + nombre.substring(posicion+1, tamano);

    System.out.println(nombreConvertido);
} 
            

Comentar

Para poder realizar comentarios. Primero debes inicar sesión o crear una cuenta.