Differences

This shows you the differences between two versions of the page.

--- apuntes:introduccion [2023/05/28 15:14] – [Scanner] Santiago Faci
+++ apuntes:introduccion [2023/10/22 12:28] (current) – [Sentencias prácticas] Santiago Faci
@@ Line 1: / Line 1: @@
 ====== Introducción al lenguaje Java ======
+===== Algo de código para empezar =====
+<code java>
+package com.codeandcoke.helloworld;
+/*
+ * Primer programa escrito en Java
+ */
+public class HelloWorld {
+  public static void main(String args[]) {
+    System.out.println("Hello students!");
+  }
+}
+</code>
+  * Los comentarios se escriben entre los caracteres /* y */ y pueden ocupar varias líneas
+  * Si un comentario sólo ocupa una línea se puede escribir justo después de los caracteres <nowiki>//</nowiki>
+  * La instrucción ''System.out.println("Hello Students")'' escribe el texto indicado por pantalla
+  * Cada sentencia de código se termina siempre con un '';''
+  * La definiciones de las clases y métodos no se consideran sentencias y no terminan con el caracter '';'' ya que definen nuevos bloques de código
+  * Cada bloque de código se inicia con el caracter ''{'' y termina con ''}''
+===== Palabras clave =====
+<figure>
+{{ keywords.png }}
+<caption>Palabras clave del lenguaje Java (Fuente: https://docs.oracle.com)</caption></figure>
+===== Proceso de desarrollo de una aplicación Java =====
+=== Algunas consideraciones ===
+  * Normalmente una aplicación se corresponde con un Proyecto (en IntelliJ IDEA en nuestro caso)
+  * Estructura basada en paquetes (carpetas) y debemos especificar uno como mínimo
+  * La unidad mínima de un proyecto es la clase (normalmente pública) y normalmente cada una se escribe en un fichero de código
+  * La unidad mínima de ejecución es el método que normalmente estará compuesto de un conjunto de instrucciones relacionadas
+  * Como mínimo tendrá que haber una clase pública con el método public static void main(String args[]), que será el punto de arranque cuando se ejecute el proyecto
+  * El compilador nunca procesa los comentarios
+  * Nunca debemos editar/modificar los ficheros del proyecto que no sean código Java
+  * En definitiva, a la hora de escribir el código debemos seguir la [[https://www.oracle.com/technetwork/java/codeconventions-150003.pdf|Guía de Convenciones de Java]]
+=== Estructura de un proyecto Java ===
+<figure>
+{{ java-project.png }}
+<caption>Estructura de un proyecto Java</caption></figure>
+=== Proceso de creación de una aplicación ===
+  * Al compilar, cada clase de código genera un fichero .class y sólo una de ellas será la que inicie la aplicación
+  * No es raro que un proyecto pueda contener más de 100 clases, a lo que habría que sumar otros recursos (texto, imágenes, . . .)
+  * Lo normal es que el código compilado se empaquete como .jar o .war
+  * Junto con las clases compiladas se empaqueta el manifiesto de la aplicación, donde se especifica, entre otras cosas, cuál es la clase que contiene el método main (punto de arranque de la aplicación)
+  * Los IDE incorporan menús para facilitar la creación de empaquetados y manifiestos del proyecto
+  * En IntelliJ IDEA le llaman artifacts y se pueden configurar desde el menú ''File->Project Structure'' y lanzar su creación cuando sea
+  * El artifact quedará almacenado en la carpeta ''out/artifacts/NombreProyecto_jar'' del proyecto
+  * Dependiendo de cómo esté configurado el Sistema Operativo podemos lanzar la aplicación simplemente haciendo doble-click sobre el empaquetado (HelloWorld.jar, por ejemplo)
 ===== Los comentarios =====
@@ Line 77: / Line 134: @@
   * ''String'' Permite almacenar cadenas de texto de longitud variable (cualquier caracter)
   * ''char'' Permite almacenar un solo caracter
+<figure>
+{{ primitives.png }}
+<caption>Tipos de datos primitivos en Java</caption></figure>
 En el programa, cuando se quiere hacer uso de una variable, se debe escribir el tipo de datos separado del nombre por un espacio. Por ejemplo, para declarar una variable de los tipos que hemos visto anteriormente sería como sigue:
@@ Line 167: / Line 228: @@
 Con todo esto, por norma general, siempre podremos convertir el valor de una variable a otra variable de distinto tipo, siempre y cuando tenga sentido representar dicho valor como otro tipo de dato. Por ejemplo, el dígito 1 puede ser interpretado como el número ''1''  pero también se podría interpretar como el caracter '''1'''  y como la cadena de texto ''"1"'' .
+=== Conversión implícita ===
 Algunas conversiones resulta bastante triviales y las hará Java por nosotros. Es lo que se conoce como una conversión ímplicita, ya que no requiere ninguna codificación extra por parte del programador y no suponga ninguna pérdida en el valor. Veamos un ejemplo donde un valor entero se convierte de forma implícita a un tipo entero:
@@ Line 183: / Line 246: @@
 System.out.println(otroNumero);
 </code>
+=== Conversión explícita ===
 Para poder llevar a cabo por el momento una conversión explícita de tipos sencilla, podemos interponer el tipo de dato al que queramos convertir el valor (encerrado entre paréntesis). Aunque hay que tener en cuenta que esto sólo se podrá hacer entre tipos de datos compatibles (''String''  no lo es con ninguno de los tipos numéricos). Por ejemplo:
@@ Line 237: / Line 302: @@
 public static final float IVA = 0.21;
 public static final int NUMERO_PAGINAS = 10;
+</code>
+===== Enumeraciones =====
+  * Permiten definir nuevos tipos de datos con rangos de valores muy limitados
+  * Sustituyen a las constantes para casos en los que éstas estaban relacionadas entre sí (distintos valores de un mismo rango)
+  * Al final no dejan de ser una serie de constantes pero agrupadas entre sí y con cierto contexto añadido
+  * Una vez definida una enumeración, es posible definir variables de ese tipo cuyos posibles valores serán aquellos que se hayan definido en la enumeración
+<code java>
+public enum Direccion {
+  ARRIBA, ABAJO, DERECHA, IZQUIERDA
+}
+. . .
+private Direccion direccion;
+direccion = Direccion.ABAJO;
+</code>
+=== Definir tipos enumerados ===
+<code java>
+public enum Estacion {
+  PRIMAVERA (10, 20.5f),
+  VERANO (23, 40),
+  OTONO (5.3f, 15),
+  INVIERNO (-2.1f, 10);
+  private final float temperaturaMinima;
+  private final float temperaturaMaxima;
+  Estacion(float minima, float maxima) {
+    temperaturaMinima = minima;
+    temperaturaMaxima = maxima;
+  }
+  public float temperaturaMinima() {
+    return temperaturaMinima;
+  }
+  public float temperaturaMaxima() {
+    return temperaturaMaxima;
+  }
+  public float diferenciaTemperatura() {
+    return temperaturaMaxima - temperaturaMinima;
+  }
+}
 </code>
@@ Line 243: / Line 355: @@
 ==== Clase Object ====
+Es la clase de la que todas las demás clases heredan automáticamente. De esa manera adquieren sus atributos y métodos. Por eso motivo, cualquier objeto Java contiene siempre una estructura mínima y común para todos.
+Los métodos de esta clase con los que es más habitual trabajar son los siguientes:
+  * ''equals(Object object)'': Permite comparar dos objetos cualquiera
+  * ''hashCode()'': Permite conocer el hash de un objeto para determinar si es el mismo que otro (útil para algunas colecciones, por ejemplo)
+  * ''toString()'': Permite representar, automáticamente, cualquier objeto como una cadena de texto cuando sea necesario
+Lo habitual es, una vez creada la clase (y por tanto heredados), modificarlos para adaptarlos al comportamiento específico de cada clase (lo veremos más adelante en el tema de Programación Orientada a Objetos).
+<code java>
+public class Student {
+  private String studentId;
+  private String name;
+  private String lastName;
+  .....
+  // TODO getters y setters
+  . . .
+  @Override
+  public int hashCode() {
+    return studentId.hashCode();
+  }
+  @Override
+  public boolean equals(Object object) {
+    if (object == null) return false;
+    if (!(object instanceof Student) return false;
+    Student student = (Student) object;
+    if (student.geStudentId() != studentId)
+      return false;
+    }
+    return true;
+  }
+  @Override
+  public String toString() {
+    return studentId + (" + name + " " + lastName + ")";
+  }
+}
+</code>
 ==== Clases String y StringBuilder ====
@@ Line 287: / Line 440: @@
 ==== Clase Math ====
-==== Scanner ====
 Clase con métodos estáticos para realizar todo tipo de operaciones matemáticas
@@ Line 300: / Line 451: @@
   * ''sqrt(numero)'': Calcula la raíz cuadrada del número que se pasa como parámetro
-=== Clase Random ===
+==== Scanner ====
+Clase que permite leer una entrada de datos, por ejemplo, la entrada por teclado para almacenar en una variable lo que el usuario escribe:
+<code java>
+Scanner keyboard = new Scanner(System.in);
+String input = keyboard.nextLine();
+String integerNumber = keyboard.nextInt();
+</code>
+==== Clase Random ====
+Clase que permite generar valores pseudoaleatorios algo más cómodos que los generados con Math.random() (números enteros, números enteros entre un rango dado, valores booleanos, . . . )
+<code java>
+Random generator = new Random();
+int integerNumber = generator.nextInt(10);
+boolean booleanValue = generator.nextBoolean();
+</code>
+===== Code snippets =====
+==== Mostrar un mensaje en pantalla ====
+<code java>
+System.out.println("Hola que tal");
+. . .
+int cantidad = 10;
+System.out.println("La cantidad es " + cantidad);
+</code>
+==== Generar un número aleatorio entre 0 y 10 ====
+<code java>
+Random generador = new Random();
+int numeroAleatorio = generador.nextInt(10);
+</code>
+==== Simular el lanzamiento de una moneda ====
+<code java>
+Random generador = new Random();
+boolean lanzamientoMoneda = generador.nextBoolean();
+</code>
+==== Leer la entrada del usuario por teclado ====
+<code java>
+Scanner teclado = new Scanner(System.in);
+String entrada = teclado.nextLine();
+</code>
+==== Reproducir un fichero de audio ====
+<code java>
+try {
+  File f = new File("sample.wav");
+  AudioInputStream audioIn = AudioSystem.getAudioInputStream(f.toURI().toURL());
+  Clip clip = AudioSystem.getClip();
+  clip.open(audioIn);
+  clip.start();
+} catch (IOException | UnsupportedAudioFileException | LineUnavailableException ioe) {
+  ioe.printStackTrace();
+}
+</code>
 ----
 ====== Ejercicios ======
+{{ ejercicio.png}}
   - Haz un programa que solicite dos números y diga si son o no iguales