Mini curso Java [En progreso]

CitarCualquier sugerencia, por favor, háganmelo saber por MP

CitarEn caso tengan problemas con los ejercicios planteados, abrir un tema de la manera normal

• JDK
  
  
  
  • No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
• Netbeans
  
  
  
  • No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
• JavaFX Scene Builder
  
  
  
  • No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
• PostgreSQL
  
  
  
  • No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
    
• GlassFish
  
  
  
  • No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

• Siempre debe tener visibilidad pública y ser estático.
• Siempre debe retornar void
• Siempre debe tener como parámetro una colección de String (String[])

public class Class01 {
    public static void main(String[] args) {
        /*
            Aquí irá el código que se ejecutará
        */
    }
}

• Entero de 8 bits.
• Valor mínimo: -128
• Valor máximo: 127
• Valor por defecto: 0
• Cuándo utilizarlo: Cuando queramos guardar enteros pequeños.
• Valor por defecto: 0
• Ejemplo: byte a = 100 byte b = -50

• Entero de 16 bits.
• Valor mínimo: -32,768
• Valor máximo: 32.767
• Cuándo utilizarlo: Cuando queramos guardar enteros medianos.
• Valor por defecto: 0
• Ejemplo: short s = 10000 short r = -20000

• Entero de 32 bits.
• Valor mínimo: -2147483648
• Valor máximo: 2147483647
• Cuándo utilizarlo: Cuando queramos guardar enteros grandes.
• Valor por defecto: 0
• Ejemplo: int a = 100000 int b = -200000

• Entero de 64 bits
• Valor mínimo: -9223372036854775808
• Valor máximo: 9223372036854775807
• Cuándo utilizarlo: Cuando se quiera almacenar enteros muy grandes.
• Valor por defecto: 0
• Ejemplo: long a = 100000000; long b = -200000000

• Número de coma flotante de precisión simple de 32 bits
• Cuándo utilizarlo: Cuando se quiera almacenar números reales con precisión simple.
• Valor por defecto: 0,0f
• Ejemplo: float f1 = 234,5f

• Número de coma flotante de doble precisión de 64 bits
• Cuándo utilizarlo: Cuando se quiera almacenar números reales con precisión doble.
• Valor por defecto: 0,0d
• Ejemplo: double d1 = 123,4

• Representa un bit de información (verdadero o falso)
• Solo hay dos posibles valores: true y false
• Éste tipo de dato se utiliza para armar condiciones en estructuras condicionales
• Valor predeterminado: falso
• Ejemplo: boolean esCasado = true

• Carácter Unicode de 16 bits.
• Valor mínimo: '\u0000' (0)
• Valor máximo: '\uffff' (65.535)
• Cuándo utilizarlo: Cuando se quiera almacenar cualquier carácter.
• Ejemplo: char letra = 'A'

• Colección de Char
• Valor por defecto: null
• Cuándo utilizarlo: Cuando se quiera almacenar texto.
• Ejemplo: String miTexto = "Éste es un texto !#@ "

byte edad;

byte edad;
edad = 21;

byte edad = 21;

• Debe de tener la palabra reservada final
• Una constante debe ser inicializada
• Una constante es de solo lectura. No se puede cambiar su valor una vez definido.
• Como recomendación, una constante debe estar en mayúsculas (uppercase)

final float PI = 3.1416

final byte IGV = 18; // 18% de una venta = IGV (impuesto)

final byte IGV = 18;
IGV = 25;

• Una variable es un espacio de memoria que tiene asociado un identificador
• Una variable puede ser declarada y asignada o inicializada (ambas juntas)
• El valor de una variable puede variar durante la ejecución de una aplicación
• Una constante es una variable cuyo valor una vez definido no puede cambiar
• Una constante debe de tener la palabra reservada final y debe ser inicializada
• Una constante debe utilizarse para representar valores fijos que no cambiarán en el tiempo (PI, IGV, etc)

• next: lee una sola línea consecutiva. Si encuentra un espacio, deja de leer.
• nextLine: lee una línea completa, incluídos espacios en blanco.
• nextByte: lee un entero pequeño.
• nextShort: lee un entero mediano.
• nextInt: lee un número entero.
• nextFloat: lee un número de coma flotante de precisión simple.
• nextDouble: lee un número de coma flotante de precisión doble.
• nextBoolean: lee un número booleano.

Scanner scanner = new Scanner(System.in);

import java.util.Scanner;

public class Class05 {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        
        System.out.println("Ingrese su nombre");
        String singleLine = reader.next();
        reader.nextLine();
        System.out.println("Ingrese sus apellidos");
        String fullLine = reader.nextLine();
        System.out.println("Ingrese un número entre -128 y 127");
        byte b = reader.nextByte();
        System.out.println("Ingrese un número entre -32768 y 32767");
        short s = reader.nextShort();
        System.out.println("Ingrese un número de precisión simple");
        float f = reader.nextFloat();
        System.out.println("Ingrese un número de precisión doble");
        double d = reader.nextDouble();
        System.out.println("Ingrese un valor booleano");
        boolean bool = reader.nextBoolean();
        
    }
}

public class Excercise01 {
    public static void main(String[] args) {
        Scanner reader;
        byte number1;
        byte number2;
        byte resultado;
        number1 = 15;
        number2 = 45;
        resultado = number1 * number2;
    }
}

public class Excercise02 {
    public static void main(String[] args) {
        System.out.println("Hola mundo!");
        System.out.println(35);
    }
}

public class Excercise03 {
    public static void main(String[] args) {
        Scanner reader;
        int number1 = 0;
        int number2 = 0;
        reader = new Scanner(System.in);
        System.out.println("Ingrese un número entero");
        number1 = reader.nextInt();
        System.out.println("Ingrese un número entero");
        number2 = reader.nextInt();
    }
}

public class Excercise03 {
    public static void main(String[] args) {
        Scanner reader;
        int number1 = 0;
        int number2 = 0;
        int result = 0; // nueva variable

        reader = new Scanner(System.in);
        System.out.println("Ingrese un número entero");
        number1 = reader.nextInt();
        System.out.println("Ingrese un número entero");
        number2 = reader.nextInt();
        resultado = number1 * number2; // almacenamos el resultado de la operación
    }
}

import java.util.Scanner;

public class Excercise03 {
    public static void main(String[] args) {
        Scanner reader;
        int number1 = 0;
        int number2 = 0;
        int result = 0;
        reader = new Scanner(System.in);
        System.out.println("Ingrese un número entero");
        number1 = reader.nextInt();
        System.out.println("Ingrese un número entero");
        number2 = reader.nextInt();
        result = number1 * number2;
        System.out.println(result); // mostramos el resultado
    }
}

• Ingresar dos números de coma flotante de precisión simple, dividirlos y mostrar el resultado.

if(20/2 == 10) {
	System.out.println("El resultado es diez");
}

Si 20 entre 2 es 10, entonces:
	Imprimir "El resultado es diez"
Fin Si

if(20 * 5 == 100) {
	System.out.println("El resultado es 100");
} else {
	System.out.println("El resultado no es 100");
}

Si 20 * 5 = 100, entonces:
	Imprimir "El resultado es 100"
Si no:
	Imprimir "El resultado no es 100"
Fin Si

Scanner reader = new Scanner(System.in);
byte edad = 0;

System.out.print("Ingrese su edad:");
edad = reader.nextByte();

if(edad < 18) {
	System.out.println("Usted es niño o adolescente");
} else if(edad > 17 && edad < 21) {
	System.out.println("Usted es un joven");
} else if(edad > 20 && edad < 60) {
	System.out.println("Usted es un adulto");
} else {
	System.out.println("Usted es un anciano");
}

Ingresar edad como entero
Si edad < 18, entonces
	Imprimir "Usted es niño o adolescente"
Si no
	Si edad > 17 y edad < 21, entonces
		Imprimir "Usted es joven"
	Fin Si
Si no
	Si edad > 20 y edad < 60, entonces
		Imprimir "Usted es un adulto"
	Fin Si
Si no
	Imprimit "Usted es un anciano"
Fin Si

Ingresar base como real
Ingresar altura como real
Declarar area como real
area = base * altura / 2
Si area < 10, entonces
	Imprimir "El triángulo es pequeño"
Si no
	Si area >= 10 y area < 20, entonces
		Imprimir "El triángulo es mediano"
	Fin Si
Si no
	Imprimir "El triángulo es grande"
Fin Si

public class Clase09 {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        float base;
        float altura;
        float area;
        
        System.out.println("Ingrese la base");
        base = reader.nextFloat();
        System.out.println("Ingrese la altura");
        altura = reader.nextFloat();
        
        area = (base * altura) / 2;
        
        System.out.println("Área: " + area);
        if(area < 10) {
            System.out.println("El triángulo es pequeño");
        } else if(area >= 10 && area < 20) {
            System.out.println("El triángulo es mediano");
        } else {
            System.out.println("El triángulo es grande");
        }
    }
}

public class Clase09 {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        float base;
        float altura;
        float area;
        
        System.out.println("Ingrese la base");
        base = reader.nextFloat();
        System.out.println("Ingrese la altura");
        altura = reader.nextFloat();
        
        area = (base * altura) / 2;
        
        System.out.println("Área: " + area);
        if(area < 10) {
            System.out.println("El triángulo es pequeño");
        if(area > 10) {
            System.out.println("El triángulo es mediano");
        if(area > 25) {
            System.out.println("El triángulo es grande");
        }
    }
}

CitarEl triángulo es mediano.
El triángulo es grande.

mientas <condición> hacer
    instrucciones
fin mientras

while (<condición>) {
    // instrucciones
}

hacer
    <instrucciones>
mientras  (<condición>)

do {
    // instrucciones
} while(<condición>);

• variable de control: es la variable que controla la condición del bucle.
• condición: es la expresión que for evaluará antes de cada iteración y que pone un límite al bucle.
• aumento/decremento: es el aumento o decremento de la variable de control. Es importante ésta parte ya que si no fijamos un incremento o decremento, la condición nunca terminará.

para i <- x hasta n hacer incremento i+1 hacer
    <instrucciones>
fin para

for(byte indice = 0; indice < 10; indice++) {
    // instrucciones
}

System.out.println("¿Desea ingresar datos? S/N");
char seguir = reader.next().charAt(0); // centinela
while(seguir == 'S') {
	String nombre;
	System.out.println("Ingrese su nombre");
	nombre = reader.nextLine();
	System.out.println(nombre);
	System.out.println("¿Desea seguir? S/N");
	char = reader.next().charAt(0);
}

char seguir; // centinela
do {
	String nombre;
	System.out.println("Ingrese su nombre");
	nombre = reader.nextLine();
	System.out.println(nombre);
	System.out.println("¿Desea seguir? S/N");
	char = reader.next().charAt(0);
} while(seguir == 'S');

System.out.println("¿Cuántos usuarios desea guardar");
byte maximoUsuarios = reader.nextByte();
for(byte indice = 0; indice < maximoUsuarios; indice++) {
	// proceso
}

• Nombre del empleado.
  
• Horas trabajadas.
  
  Proceso:
  
  
• Tarifa por hora normal y por hora extra.
  
• Salario.
  
  Salida:
  
  
• Salario.
  
  Diagrama de flujo:
  
  
  
  Código:
  
  

  
  package org.underc0de.curso;
  
  import java.util.Scanner;
  
  /**
   *
   * @author Gustavo
   */
  public class Repetitivas {
      public static void main(String[] args) {
          final byte THORA_NORMAL = 20;
          final byte THORA_EXTRA = 25;
          Scanner reader = new Scanner(System.in);
          
          byte numeroEmpleados;
          System.out.println("¿Cuántos empleados desea ingresar?");
          numeroEmpleados = reader.nextByte();
          reader.nextLine(); // libera el fin de línea (enter)
          
          for(byte actual=1; actual<=numeroEmpleados; actual++) {
              String nombre;
              byte horasTrabajadas;
              short salarioNeto;
              System.out.println("Ingrese el nombre del empleado");
              nombre = reader.nextLine();
              System.out.println("Ingrese las horas trabajadas");
              horasTrabajadas = reader.nextByte();
              if(horasTrabajadas <= 40) {
                  salarioNeto = (short) (horasTrabajadas * THORA_NORMAL);
              } else {
                  byte horasExtras;
                  short horasNormales;
                  short salarioBase;
                  short salarioExtra;
                  horasExtras = (byte) (horasTrabajadas - 40);
                  horasNormales = (short) (horasTrabajadas - horasExtras);
                  salarioBase = (short) (horasNormales * THORA_NORMAL);
                  salarioExtra = (short) (horasExtras * THORA_EXTRA);
                  salarioNeto = (short) (salarioBase + salarioExtra);
              }
              System.out.println("El salario del empleado "+nombre+" es "+salarioNeto+"\n\n");
              reader.nextLine(); // libera el final de línea (enter)
          }
      }
  }

  
  
  La razón por la que hacemos (short) es porque, por defecto Java devuelve las operaciones aritméticas como int. Entonces, dado que las variables son short, hay una pérdida de precisión y debemos convertir ese int a short. Si no desean hacer ésto, simplemente declaren todo como int.
  
  

  CitarCuando ingresas un número y das enter, el enter (fín de línea) ingresado queda en memoria, es por ésta razón que cuando llamamos a nextLine() luego de leer un número, el nextLine() lee el enter ingresado anteriormente porque ha quedado en memoria y se salta. Para evitar ésto debemos liberar el enter llamando a nextLine() luego de leer un número y antes de leer un texto.

  
  

  ---

  4. EJERCICIOS PROPUESTOS

  ---

  
  
  1.   Leer 10 números e imprimir solamente los números positivos.
  2.   Leer 20 números e imprimir cuantos son positivos, cuantos negativos y cuantos neutros
  3.   Imprima la suma de todos los números pares que van del 1 al 100 y diga cuántos hay.
  
  

  ---

  
  
  Glosario
  
  bucle, loop: estructura repetitiva (while, do while y for).
  centinela: variable que controla el ciclo de vida de un bucle.

Citarsegún <expresión> hacer
    caso, = <valor>
        Instrucción 1
        Instrucción 2
    caso, = <valor>
        Instrucción 1
        Instrucción 2
    caso, = <valor>
        Inscripción 1
        Inscripción 2
    caso, sino
        Instrucción 1
fin según

switch(<expresión>) {
	case <valor>:
		/* Instrucciones */
		break;
	case <valor>:
		/* Instrucciones */
		break;
	case <valor>:
		/* Instrucciones */
		break;
	default: // opcional
		/* Instrucciones */
}

for( temporal = 50; true; break){
  if( temporal == 25) { /* accion1; */}
  if( temporal == 35 || temporal == 23) { /* accion2 ; */ }
  /* en caso no se cumpla ninguna condición se ejecuta ésto:
   * (default)
   * /
   // acción si no se cumple ninguna condición (por defecto)
} 

package org.underc0de.curso;

import java.util.Scanner;

/**
 *
 * @author Gustavo
 */
public class Clase10 {

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        int numero;
        System.out.println("Ingrese un número entre 1 y 7");
        numero = reader.nextInt();
        switch (numero) {
            case 1:
                System.out.println("El día es Lunes");
                break;
            case 2:
                System.out.println("El día es Martes");
                break;
            case 3:
                System.out.println("El día es Miércoles");
                break;
            case 4:
                System.out.println("El día es Jueves");
                break;
            case 5:
                System.out.println("El día es Viernes");
                break;
            case 6:
                System.out.println("El día es Sábado");
                break;
            case 7:
                System.out.println("El día es Domingo");
                break;
            default:
                System.out.println("Debe ingresar un número entre 1 y 7");
        }
    }
}

• Aro de Llantas
  
• Asiento
  
• Número de cambios
  
• Tipo (montañera, etc)
  
• Color
  
  Todas esas características son las propiedades de una bicicleta. Tiene una medida de aro de llanta, un asiento, número de cambios de velocidad, un tipo que determina si es montañera o de otro tipo y un color.
  
  Métodos/funciones de un objeto:
  
  Por otro lado, una bicileta tiene muchos comportamientos, como por ejemplo:
  
  
• Acelerar
  
• Frenar
  
• Cambiar de velocidad
  
  Todos esos comportamientos, son los métodos o funciones de una bicicleta. Éstos comportamientos describen las cosas que puede hacer la bicicleta.
  
  Por lo tanto, un objeto es una abstracción o representación de una entidad real que tiene características (propiedades) y ciertos comportamientos (métodos o funciones) que lo describen.

public class Carro {

}

• Constructor o constructores (sobrecarga)
  
• Propiedades (o atributos, campos, como suelen llamarles también) (características)
  
• Métodos (comportamientos)
  
  Además, tiene las siguientes características:
  
  
• Se le asigna un modificador de acceso (public, private, por defecto)
  
• Modificador de estado (static, final)
  
• Notación PascalCase (La primera letra de cada palabra en mayúscula)
  
  PROPIEDADES, ATRIBUTOS O CAMPOS
  
  Son como ya dijimos las características de un objeto. Las propiedades de una clase en Java tienen las siguientes características:
  
  
• Modificador de acceso (public, private, protected, por defecto)
  
• Tipo de dato (String, int, float, doublé, byte, short, etc)
  
• Modificador de estado (static, final)
  
• Notación camelCase (la primera letra de la primera palabra en minúscula y las primeras letras de las palabras siguientes en mayúsculas)
  
  Ej:
  
  

  public class Carro {
  
      private String color;
  
  }

  
  
  MÉTODOS O FUNCIONES
  
  Los métodos en Java son los comportamientos del objeto. Estos cumplen las siguientes características:
  
  
• Modificador de acceso (public, private, protected, por defecto)
  
• Valor de retorno (void, String, int, float, etc)
  
• 0 o más parámetros (variables pasadas a un método)
  
• Notación camelCase (la primera letra de la primera palabra en minúscula y las primeras letras de las palabras siguientes en mayúsculas)
  
  Ej
  
  

  
  public class Carro {
  
      private String color;
      private int velocidad = 150; // km/h
  
      public void acelerar() {
          System.out.println("Acelerando...");
      }
  
      public int obtenerVelocidad() {
          return velocidad;
      }
  
  }

  
  
  La palabra reservada return se usa para devolver valores desde un método. Si el tipo de retorno es void y se usa return, entonces la ejecución del método terminará automáticamente.
  
  Para pasar datos a un método, basta pasarlos entre los paréntesis, separados por comas si hay más de uno:
  
  

  public void establecerVelocidad(int nuevaVelocidad) {
      velocidad = nuevaVelocidad;
  }

  
  
  CONSTRUCTOR
  
  Un constructor es un método especial, el cual sirve como inicializador y creador de nuevas instancias de un tipo de objeto (clase). En cada creación de objetos, se llama al constructor implícitamente; sin él, no sería posible la creación de objetos. Un constructor tiene las siguientes características:
  
  
• No tiene un valor de retorno
  
• Debe llamarse exactamente como la clase
  
  Ej:
  
  

  
  public class Carro {
  
      public String color;
      public int velocidad = 150;
  
      public Carro() {
  
      }
  
      ...
  
  }

  
  
  Generalmente se aprovecha el constructor para inicializar propiedades del objeto. Por ejemplo:
  
  

  public Carro(String nuevoColor, int nuevaVelocidad) {
      color = nuevoColor;
      velocidad = nuevaVelocidad;
  }

  
  
  CREACIÓN DE OBJETOS
  
  Como ya dijimos, la creación de objetos se lleva a cabo por medio del constructor de la clase. Para crear un objeto de tipo Carro basta con hacer:
  
  

  
  Carro miCarro = new Carro();
  Carro miOtroCarro = new Carro("Blanco", 250);

  
  
  Ahora podemos llamar a los métodos de Carro, así:
  
  

  int velocidad = miCarro.obtenerVelocidad(); // retorna null porque no tiene un valor definido
  int velocidad2 = miOtroCarro.obtenerVelocidad(); // retorna 150

  
  
  ¿Cómo se lleva a cabo la creación de objetos?
  
  La palabra reserva new instancia (crea un nuevo objeto de la clase) y la coloca en memoria asociándose a una dirección. Allí, se le asigna un identificador único y por medio de este, podrá ser ubicado y llamado desde su dirección en memoria.
  
  

  CitarPlus: Cada vez que se crea un objeto, éste se guarda en el Stack, que es un apartado donde Java almacena los objetos, mientras que las variables y llamadas a métodos, se almacenan en el Heap.

  
  El código de la clase Carro quedaría así:
  
  

  
  public class Carro {
      private String color;
      private int velocidad;
  
      public Carro() {}
  
      public Carro(Sring nuevoColor, String nuevaVelocidad) {
          color = nuevoColor;
  	velocidad = nuevaVelocidad;
      }
  
      public int obtenerVelocidad() {
  	return velocidad;
      }
  
      public void establecerVelocidad(int nuevaVelocidad) {
  	velocidad = nuevaVelocidad;
      }
  
  }

  
  
  Fíjate que hemos definido dos veces el constructor de la clase, a esto se le llama sobrecarga y puede aplicarse tanto a métodos como a constructores. Esto lo veremos en el próximo capítulo.

<visibilidad> <modificador> <nombre> (<parámetros>) { ... }

public String createCar(String brand) {
    return "Auto " + brand + " creado";
}

public String createCarWithColor(String brand, String color) {
    return "Auto " + brand + " color " + color + " creado";
}

public String createCar(String brand) {
    return "Auto " + brand + " creado";
}

public String createCar(String brand, String color) {
    return "Auto " + brand + " color " + color + " creado";
}

public String createCar(String brand, String color, String hp) {
    return "Auto " + brand + " color " + color + " y " + hp + " caballos de fuerza creado";
}

• Un método sobrecargado debe cambiar los parámetros del método a sobrecargar(menos o más).
  
  El siguiente ejemplo muestra una sobrecarga errónea de un método:
  
  

  
  public int sumar(int x, int y) { ... }
  
  public float sumar(int x, int y) { ... } // error, debe cambiar parámetros

  
  
  
  SOBRECARGA DE CONSTURCTORES
  
  La sobrecarga de constructores es igual que la de los métodos. Veamos un ejemplo para más detalle:
  
  

  
  public class User {
  
      private String id;
      private String name;
  
      public User() {
  	this("", "");
      }
  
      public User(String id) {
          this(id, "");
      }
  
      public Usuer(String id, String name) {
   	this.id = id;
  	this.name = name;
      }
  
  }

  
  
  Vemos que hemos sobrecargado el constructor por defecto User(), el primero pasándole un String id, y el segundo un String id y un String name. Lo curioso aquí es la instrucción this(...). Veremos más adelante el concepto de this, pero como adelanto les diré. La palabra reservada this hace referencia a la instancia. Es decir, si hago: this(id, ""), -> this = objeto User -> objeto User(id, ""). Por lo tanto, como this hace referencia a la instancia, podemos acceder tanto a los contructores, métodos y atributos. Ya veremos más acerca de this un poco más adelante.