Este debe ser el título, Resúmenes de Fundamentos de Administración y Gestión

¡Descarga Este debe ser el título y más Resúmenes en PDF de Fundamentos de Administración y Gestión solo en Docsity!

1 - 9 - 2021 Fundamentos de

Programación:

Java

Miguel Toro

UNIVERSIDAD DE SEVILLA

Introducción a Java 1 Objetivos y agradecimientos Para aprender a programar lo mejor es programar. En esta asignatura de Fundamentos de Programación vamos a aprender los conceptos básicos de la programación. Estos conceptos los vamos a concretar en dos lenguajes: Python y Java. En este volumen veremos Java. Los lenguajes de programación tienden a ir compartiendo las mismas ideas básicas. Cada lenguaje va tomando prestadas las ideas más novedosas aportadas por otros. Aunque cada lenguaje tiene sus particularidades, podemos decir que los lenguajes de programación van convergiendo hacia elementos comunes a todos ellos. Por ello parecen sensato aprender las ideas comunes a los principales lenguajes actuales y extrapolar ideas y conceptos de unos a otros. Vamos a abordar conceptos en Java comunes con Python que se pueden extender a otros. El Java hay dos estilos de programación que queremos aprender: el estilo funcional usando streams y el más clásico estilo imperativo usando iterables. El diseño de tipos ocupará un lugar central en este material. Al final se incluyen varios ejemplos que parten de un diseño de tipos. El material en este texto procede de la experiencia de varios años de enseñanza de la asignatura de Fundamentos de Programación en la Universidad de Sevilla. Mucho de este material está tomado de versiones anteriores de los profesores Mariano González, Fermín Cruz y Pepe Riquelme, a los que quiero agradecer sus esfuerzos y dedicación. Estas versiones anteriores han sido transformadas y actualizadas hasta alcanzar la forma actual. Sus defectos son responsabilidad única del autor. En https://github.com/migueltoro/clase_primero_2020 puede encontrarse el código de los ejemplos. Futuras versiones aparecerán en https://github.com/migueltoro/clase_primero_*. Miguel Toro Sevilla, Septiembre de 2021

• Conceptos básicos de la P.O.O. Contenido
  • Objetos
  • Clases, registros e interfaces
  • Estructura de un programa en Java
• Elementos básicos del lenguaje
  • Identificadores
  • Palabras reservadas de Java
  • Literales
  • Comentarios
• Tipos de datos
  • Tipos proporcionados por Java
• Variables y Constantes
  • Variables
  • Constantes...............................................................................................................................
• Expresiones y operadores
  • Expresiones
  • Operadores y conversiones de tipos
  • Precedencia y asociatividad de los operadores
• El tipo String, tipos para el manejo de fechas
  • Tipo String
  • Tipos para el manejo de fechas y horas
• Sentencias de control selectivas
  • Sentencia if-else
  • Sentencia switch......................................................................................................................
• Agregados de datos
  • Listas
  • Conjuntos
  • El tipo Map
• Lectura y escritura de datos en pantalla y ficheros - Introducción a Java
• Sentencias de control iterativas
  • Sentencia while
  • Sentencia for clásico................................................................................................................
  • Sentencia for extendido
  • Sentencia break
• Streams
• Tipos genéricos, registros y clases
  • Atributos..................................................................................................................................
  • Paso de parámetros
  • Parsing: método de factoría a partir de String
  • Cotas sobre parámetros de tipo..............................................................................................
• Reutilización y Herencia
  • Grafo de tipos
• Igualdad, identidad y orden natural
  • Igualdad e Identidad
  • Contrato asociado a los métodos equals, hashCode y toString
  • Orden natural, el tipo Comparable
• Restricciones y excepciones
  • Restricciones
  • Excepciones
  • Lanzamiento de excepciones
  • Gestión de excepciones...........................................................................................................
• Agregados de datos
  • La interfaz Collection
  • El tipo List
  • El tipo Set
  • El tipo SortedSet
  • La clase de utilidad Collections
  • El tipo Map
  • El tipo SortedMap
• El tipo Stream
  • Streams....................................................................................................................................
  • El tipo Stream
• Interfaces funcionales y lambda expresiones
  • La interfaz funcional Predicate................................................................................................ 4 Fundamentos de Programación: Java
  • La interfaz Function y Bifunction.............................................................................................
  • Las interfaces Unaryoperator y BinaryOperator
  • La interfaz Consumer y Biconsumer........................................................................................
  • La interface Supplier
  • Los interfaces Comparable y Comparator: orden natural y ordenes altenativos
• Métodos de factoría de streams
• Operaciones sobre streams
  • Métodos transformadores
  • Métodos acumuladores
  • Métodos consumidores
  • Otros métodos de Stream
  • Operaciones adicionales de Stream
• Lectura y escritura de ficheros y streams
  • Lectura de un fichero
  • Escritura en un fichero
• Versiones imperativas del código funcional
  • Factoría....................................................................................................................................
  • Funciones de transformación..................................................................................................
  • Acumuladores:
  • Acciones
• Diseño de rutas - Coordenadas2D - Coordenadas3D - Marca - Intervalo - Ruta
• Servicio de biclicletas de sevilla (Sevici)
• Cálculos sobre un libro
• Aeropuertos, vuelos y compañias aéreas

6 Fundamentos de Programación: Java

• Bajo acoplamiento : el acoplamiento es la dependencia entre los objetos. Dos objetos están muy acoplados si hacer cambios en las propiedades o la funcionalidad de uno de ellos repercute en tener que cambiar muchos detalles del otro. Si existen muchas dependencias entre todos los tipos de objetos, se hace muy difícil realizar cualquier cambio a la aplicación. Es por tanto deseable conseguir un bajo acoplamiento, para lo cual se emplean técnicas como los patrones de diseño, que no estudiaremos en esta asignatura. La POO (Programación Orientada a Objetos) es una forma de construir programas de ordenador donde las entidades principales son los objetos. Está basada en la forma que tenemos los humanos de concebir objetos, distinguir unos de otros mediante sus propiedades y asignarles funciones o capacidades. Estas dependerán de las propiedades que sean relevantes para el problema que se quiere resolver. Los elementos básicos de la POO son:
• Objeto
• Interfaz
• Clase o Atributos (almacenan las propiedades) o Métodos (consultan o actualizan las propiedades)
• Record: Es un tipo específico de clase
• Paquete Objetos Los objetos tienen una identidad, unas propiedades, un estado y una funcionalidad asociada:
• Cada objeto tiene una identidad que lo hace único y lo distingue del resto de objetos del mismo tipo. Puede haber varios objetos con el mismo estado pero cada uno con su identidad propia; en ese caso se dice que los objetos son iguales, pero no idénticos.
• Las propiedades son las características observables de un objeto desde el exterior de este. Pueden ser de diversos tipos (números enteros, reales, textos, booleanos, etc.).
• El estado indica cuál es el valor de sus propiedades en un momento dado.
• La funcionalidad de un objeto se ofrece a través de un conjunto de métodos. Los métodos actúan sobre el estado del objeto (pueden consultar o modificar las propiedades) y son el mecanismo de comunicación del objeto con el exterior.

Introducción a Java 7 La encapsulación es un concepto clave en la POO y consiste en ocultar la forma en que se almacena la información que determina el estado del objeto. Esto conlleva la obligación de que toda la interacción con el objeto se haga a través de ciertos métodos implementados con ese propósito (se trata de ocultar información irrelevante para quien utiliza el objeto). Las propiedades de un objeto sólo serán accesibles para consulta o modificación a través de sus métodos. La encapsulación permite definir de forma estricta las responsabilidades de cada objeto, lo que facilita la depuración de las aplicaciones cuando se detectan errores. Clases, registros e interfaces Las clases son las unidades de la POO que permiten definir los detalles del estado interno de un objeto (mediante los atributos ), obtener las propiedades de los objetos a partir de los atributos e implementar las funcionalidades ofrecidas por los objetos (a través de los métodos). Cada clase define un tipo nuevo con el cual podemos declarar variables de ese tipo y construir objetos. Normalmente para implementar una clase partimos de un diseño del tipo. Al diseñar un tipo nuevo debemos partir de los ya existentes. Es necesario decidir a qué otros tipos extender o que tipos usar. Decimos que el nuevo tipo usa aquellos tipos con los que declara sus propiedades. También puede diseñarse el nuevo tipo extendiendo algunos de los disponibles. Un tipo extiende a otro cuando le añade nueva funcionalidad es decir nuevas propiedades y métodos. Al diseñar un tipo estamos estableciendo un contrato entre los objetos de este tipo y sus posibles usuarios. Un tipo tiene un nombre y un conjunto de propiedades que son las características visibles. Cada propiedad tiene un nombre, un tipo, puede ser consultada y además modificada o sólo consultada, y puede ser una propiedad básica o una propiedad derivada. Además, las propiedades pueden ser individuales y compartidas. Las propiedades individuales son específicas de un objeto individual. Las propiedades compartidas son comunes a todos los objetos de la población del tipo. Las propiedades derivadas pueden ser calculadas a partir de las otras propiedades. Las básicas no. Los tipos inmutables solo tienen propiedades modificables. Un tipo suelen tener asociado un criterio de igualdad entre dos de ellos y en muchos casos un criterio de ordenación al que llamaremos orden natural. Para un tipo también podemos definir su representación. Es decir la forma en la que se representará el objeto mediante una cadena de caracteres. Un tipo, también, tiene métodos de factoría. Es decir mecanismos para crear objetos nuevos. Entre los métodos de factoría hay uno, que denominaremos parse , encargado de construir objetos a partir de una cadena de texto.

Introducción a Java 9 recordPunto2D(Double x,Double y)implements Comparable{ public static Punto2D of(Double x, Double y) { return new Punto2D(x, y); } public Double distanciaAlOrigen() { Double dx = this.x; Double dy = this.y; return Math.sqrt(dxdx+dydy); } @Override public String toString() { return String.format("(%.2f,%.2f)",this.x(),this.y()); } @Override public int compareTo(Punto2D p) { return this.distanciaAlOrigen() .compareTo(p.distanciaAlOrigen()); } } Una interface es un elemento de la POO que permite, establecer propiedades y funcionalidades que debe tener un tipo dado. Una interface contiene, fundamentalmente, signaturas de métodos que definen la funcionalidad pero no el cuerpo de estos. Al igual que una clase una interfaz define un tipo nuevo. Una interface se usa para establecer funcionalidades comunes a varios tipos. Como ejemplo veamos la interface Comparable que define la funcionalidad de todos los tipos que tengan un orden natural. interface Comparable { int compareTo(E other); } Un tipo E que ofrezca esta funcionalidad asegura que si un objeto o1 de ese tipo se compara con otro o2 podremos saber si es mayor, menor o igual que este. Esto se concreta en la sentencia: int r = o1.compareTo(o2); La variable r tendrá un número negativo, positivo o cero según que o1 sea menor, mayor o igual a o2. Si un tipo, implementado como class o record , ofrece la funcionalidad definida en una interface decimos que el tipo la implementa. Esto se concreta mediante implements y obliga a la clase o record a dar un cuerpo al o lo métodos contenidos en la interface.

10 Fundamentos de Programación: Java record Punto2D(Double x,Double y) implements Comparable Las propiedades básicas del tipo, las vienen como parámetros de record , x, y en el caso del Punto2D definen el estado del objeto. El estado es privado e invisible fuera del objeto. Para consultar el estado disponemos de métodos. En el caso de Punto2D disponemos de los métodos x(), y(), distanciaAlOrigen(), toString(), compareTo(Punto2D other). Mediante el operador punto (.) podemos combinar objetos y métodos para formar expresiones bien formadas. Los métodos de factoría no se combinan con objetos sino con el nombre del tipo. Siendo p1, p2 objetos del tipo Punto2D tenemos las expresiones siguientes. Unas bien bien formadas y otras no: Punto2D p1 = Punto 2 D.of(3.,4.); Double r = p1.x(); Double r2 = p1.x; //Mal, x es invisible p1.y = 3.4; //Mal, y es invisible p1.y() = 5.6; //Mal, la llamada a un método no puede estar a la izquierda Las expresiones, cuando están bien formadas, tienen un tipo y un valor. El punto (.) es, por lo tanto, un operador que combina un objeto con sus métodos y que indica que el correspondiente método se ha invocado sobre el objeto. Como hemos dicho antes el operador punto (.) también combina el nombre de una clase o registro con un método de factoría. Estructura de un programa en Java Un programa en Java está formado por un conjunto de declaraciones de tipos, interfaces y clases. Un programa puede estar en dos modos distintos. En el modo de compilación está cuando estamos escribiendo las clases e interfaces. En este modo, a medida que vamos escribiendo, el entorno va detectado si las expresiones que escribimos están bien formadas. Si el entorno no detecta errores entonces diremos que el programa ha compilado bien y por lo tanto está listo para ser ejecutado. Se llama modo de compilación porque el encargado de detectar los errores en nuestros programas, además de preparar el programa para poder ser ejecutado, es otro programa que denominamos comúnmente compilador. En el modo de ejecución se está cuando queremos obtener los resultados de un programa que hemos escrito previamente. Decimos que ejecutamos el programa. Para poder ejecutar un programa este debe haber compilado con éxito previamente y tener un método especial denominado método principal (también denominado programa principal). En otro caso no lo podremos ejecutar.

12 Fundamentos de Programación: Java Identificadores Son palabras que permiten referenciar los diversos elementos que constituyen el código. Es decir, sirven para nombrar a clases, interfaces, métodos, atributos, variables, parámetros y paquetes. Para nombrar a estos elementos, hay que seguir unas determinadas reglas para que puedan ser entendidos por el compilador. Los identificadores se construyen mediante una secuencia de letras, dígitos, o los símbolos _ y $. En cualquier caso, se debe observar que:

• No pueden coincidir con palabras reservadas de Java (ver más adelante)
• Deben comenzar por una letra, _ o $, aunque estos dos últimos no son aconsejables.
• Pueden tener cualquier longitud.
• Son sensibles a las mayúsculas, por ejemplo, el identificador min es distinto de MIN o de Min. Ejemplos de identificadores válidos son los siguientes: tiempo, distancia1, caso_A, PI, velocidad_de_la_luz Por el contrario, los siguientes nombres no son válidos (¿por qué?) 1_valor, tiempo-total, dolares%, final En general, es muy aconsejable elegir los nombres de los identificadores de forma que permitan conocer a simple vista qué representan, utilizando para ello tantos caracteres como sean necesarios. Esto simplifica enormemente la tarea de programación y – sobre todo– de corrección y mantenimiento de los programas. Es cierto que los nombres largos son más laboriosos de teclear, pero, en general, resulta rentable tomarse esa pequeña molestia. Unas reglas aconsejables para los identificadores son las siguientes:
• Las variables normalmente tendrán nombres de sustantivos y se escribirán con minúsculas, salvo cuando estén formadas por dos o más palabras, en cuyo caso, el primer carácter de cada palabra se escribirá en mayúscula. Por ejemplo: salario, salarioBase, edadJubilacion.
• Los identificadores de constantes (datos que no van a cambiar durante la ejecución del programa) se deben escribir con todos los caracteres con mayúsculas; si el identificador está compuesto por varias palabras es aconsejable separarlas con el guion bajo ( _ ). Por ejemplo : PI, PRIMER_VALOR, EDAD_MINIMA.
• Los identificadores de métodos tendrán la primera letra en minúscula, y la primera letra de las siguientes palabras en mayúscula: x, distanciaAlOrigen , etc.

Introducción a Java 13

• Los identificadores de clases e interfaces se deben escribir con el primer carácter de cada palabra en mayúsculas y el resto en minúsculas: Punto2D, Comparable , etc. Palabras reservadas de Java Una palabra reservada es una palabra que tiene un significado especial para el compilador de un lenguaje, y, por lo tanto, no puede ser utilizada como identificador. Algunos ejemplos de palabras reservadas son main, int, return, if o for. Literales Son elementos del lenguaje que permiten representar valores constantes de los distintos tipos del lenguaje. Por ejemplo, 23 es un literal de tipo Integer , 23L es un literal de tipo Long, 3.14 es un literal de tipo Double , “Guadalquivir” es un literal de tipo String y true y false son los dos literales que corresponden al tipo Boolean. Para los objetos existe un literal null que representa un objeto sin valor. Comentarios Los comentarios son un tipo especial de separadores que sirven para explicar o aclarar algunas sentencias del código, por parte del programador, y ayudar a su prueba y mantenimiento. De esta forma, se intenta que el código pueda ser entendido por una persona diferente o por el propio programador algún tiempo después. Los comentarios son ignorados por el compilador. En Java existen comentarios de línea, que se marcan con //, y bloques de comentarios, que comienzan con /* y terminan con /. // Este es un comentario de una línea / Este es un bloque de comentario que ocupa varias líneas */ Tipos de datos Tipos proporcionados por Java

Introducción a Java 15 int d = b; Los tipos primitivos tienen una funcionalidad más limitada que sus equivalentes anteriores. Como regla general recomendamos el uso de los tipos que comienzan con mayúscula. Junto a los tipos ofrecidos directamente por Java podemos incorporar, mediante librería, otros tipos usados en los cálculos matemáticos con Fraction o Complex. Los valores de estos tipos son objetos que se construyen mediante un constructor o un método de factoría. Ejemplos Fraction f1 = Fraction.getReducedFraction(6, 8); Fraction f2 = Fraction.getReducedFraction(1, 4); Fraction f3 = f1.subtract(f2); Fraction f 4 = f1.multiply(f2); Complex c = Complex.valueOf(6.2,7.1); Double re = r.getReal(); Double md = r.abs(); La información sobre estos últimos tipos se pue encontrar en Fraction, Complex. Variables y Constantes Variables Las variables son elementos del lenguaje que permiten guardar y acceder a los datos que se manejan. En Java es necesario declararlas antes de usarlas en cualquier parte del código y, por convenio, se escriben en minúsculas. Mediante la declaración indicamos que la variable guardará un valor del tipo declarado. Mediante la inicialización reciben un primer valor. Algunos ejemplos de declaraciones de variables son los siguientes: Integer valor; Double a1 = 2.25, a2 = 7.0; Character c = 'T'; String cadena= "Curso Java"; Color relleno = Color.AZUL;

16 Fundamentos de Programación: Java En la primera línea del ejemplo se declara una variable, valor , de tipo entero; en la segunda línea se declaran e inicializan dos variables, a1 y a2 , de tipo Double ; en la tercera, se declara una variable, c , de tipo Character y se inicializa; en la cuarta, se declara e inicializa la variable cadena de tipo String. Finalmente, en la última línea se declara la variable relleno del tipo enumerado Color y se inicializa con el valor AZUL. Cada declaración tiene un ámbito. Por ámbito de una declaración entendemos el segmento de programa donde esta declaración tiene validez. Más adelante iremos viendo los ámbitos asociados a cada declaración. En la mayoría de los casos, en Java un ámbito está delimitado por los símbolos {…} (llaves). Constantes Las constantes son elementos del lenguaje que permiten guardar y referenciar datos que van a permanecer invariables durante la ejecución del código. La declaración de una constante comienza por la palabra reservada final. Ejemplos de declaraciones de constantes: final Integer DIAS_SEMANA = 7; final Double PI = 3.1415926; final String TITULO = "E.T.S. de Ingeniería Informática"; En este ejemplo se declaran tres constantes, DIAS_SEMANA, PI, y TITULO, de tipo Integer , Double y String , respectivamente. Note que, por convención, los nombres de constantes se escriben en mayúsculas. Expresiones y operadores Expresiones Una expresión se forma con identificadores, valores constantes, operadores y llamadas a métodos. Toda expresión bien formada tiene asociado un valor y un tipo. Una variable dentro de una expresión decimos que está siendo usada. Para que una variable pueda ser usada tiene que haber sido declarada e inicializada previamente. Por ejemplo:

18 Fundamentos de Programación: Java Los tipos numéricos se pueden ordenar Integer, Long, Float, Double. Un valor de uno de esos tipos se convierte automáticamente en otro posterior en el orden anterior. Si se operan dos valores de tipos diferentes se convierten ambos al mayor y se operan. El tipo devuelto es el mayor. Para convertir un tipo en otro menor hay que forzarlo con operadores de casting. Estos son: (int) convierte a entero, (long) convierte a long , (double) convierte a double. A su vez los tipos Integer, Long, Float, Double disponen de los métodos intValue(), longValue(), floatValue(), doubleValue() para convertir a los tipos respectivos. Precedencia y asociatividad de los operadores El resultado de una expresión depende del orden en que se ejecutan las operaciones. Por ejemplo, si queremos calcular el valor de la expresión 3 + 4 * 2, podemos tener distintos resultados dependiendo de qué operación se ejecuta primero. Así, si se realiza primero la suma (3 + 4) y después el producto (7 * 2), el resultado es 14; mientras que si se realiza primero el producto (4 * 2) y luego la suma (3 + 8), el resultado es 11. Para saber en qué orden se realizan las operaciones es necesario definir unas reglas de precedencia y asociatividad. La tabla siguiente resume las reglas de precedencia y asociatividad de los principales operadores en el lenguaje Java. Operador Asociatividad

. [] ()

• -! ++ -- (tipo) new derecha a izquierda

• / % izquierda a derecha

• – izquierda a derecha < <= > >= izquierda a derecha == != izquierda a derecha && izquierda a derecha || izquierda a derecha ? : = += – = *= /= %= derecha a izquierda Los operadores que están en la misma línea tienen la misma precedencia, y las filas están en orden de precedencia decreciente. También se debe tener en cuenta que el uso de paréntesis modifica el orden de aplicación de los operadores. Si no hay paréntesis el orden de aplicación de los operadores viene definido por la precedencia y la asociatividad de estos definida arriba.

Introducción a Java 19 El tipo String, tipos para el manejo de fechas Tipo String Como hemos visto antes, el tipo String representa una secuencia o cadena de caracteres. El tamaño de un String es inmutable y, por lo tanto, no cambia una vez creado el objeto. Se representa por el método length. Cada carácter de la cadena ocupa una posición, comenzando por la posición 0 y terminando por la posición length()- 1. Para acceder al carácter que ocupa una posición dada se utiliza el método charAt(int i). Por ejemplo; String nombre = "Amaia"; Integer lon = nombre.length() // El valor de lon será 5 Character inicial = nombre.charAt(0) // El valor de inicial será 'A' Character ultima = nombre.charAt(lon - 1) // El valor de ultima será 'a' No es posible modificar un carácter de la cadena una vez que se ha creado. Tampoco se pueden añadir o eliminar caracteres. El tipo String es, pues, inmutable. El tipo String ofrece otros métodos para, entre otras cosas, decidir si la cadena contiene una secuencia dada de caracteres, buscar la primera posición de un carácter u obtener la subcadena dada por dos posiciones. Los detalles de estos métodos pueden verse en la documentación de la clase String en la API de Java. El tipo String es muy importante porque todos los datos que leemos de un fichero o de la consola son de tipos String. Tenemos que comprender bien como transformamos cadenas de texto a un tipo dado y viceversa. A la operación de transformar una cadena de texto en un tipo lo llamamos parse. Los tipos que nos ofrece Java ya incorporar un método de factoría para hacer este cometido. Los tipos que diseñemos nuevos es conveniente dotarlos de un método de factoría que lleve a cabo ese cometido. Integer n1 = Integer.parseInt("-345"); Long n2 = Long.parseLong(("-345"); Double r = Double.parseDouble("-34.56"); Punto2D p = Punto2D.parse(3.7,-6.7); El proceso inverso de parse en la transformación de un objeto de un tipo en una cadena de caracteres. Esto se consigue con el método toString(). Cada tipo tiene este método.