Skip to content

Commit 4ccd7a3

Browse files
author
martipatgra
committed
nuevos tipos
1 parent 69a986c commit 4ccd7a3

File tree

5 files changed

+134
-70
lines changed

5 files changed

+134
-70
lines changed

docs/about.md

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,14 @@
1-
# About
1+
# About me ❤️‍🔥
22

3-
Patricia Martí
3+
Mi nombre es *Patricia Martí*, soy Ingeniera en Informática. Durante casi una década me dediqué al desarrollo software de manera profesional en diferentes empresas nacionales e internacionales.
44

5-
p.marti2@edu.gva.es
5+
Actualmente, soy docente en el campo de la programación, donde puedo compartir con entusiasmo y pasión los conocimientos y habilidades aprendidas durante mi trayectoria.
66

7-
## Bibliografía y webgrafía
7+
_Mi objetivo es inspirar a la próxima generación de desarrolladores y ayudarles a adentrarse en el emocionante mundo de la programación y la tecnología._
8+
9+
Para cualquier consulta o mejora, pueden escribirme a través de mi correo electrónico **p.marti2@edu.gva.es**.
10+
11+
## ❤️‍🔥 Bibliografía y webgrafía
812

913
https://docs.oracle.com/en/java/
1014

docs/index.md

Lines changed: 43 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -4,11 +4,11 @@
44

55
Aquí puedes encontrar los apuntes del módulo de _Programación_, que se imparte en el primer curso del ciclo formativo de grado superior de Desarrollo de Aplicaciones Multiplataforma.
66

7-
La duración del módulo es de 256 horas lectivas, a razón de **8 horas semanales**. Se ha planificado basándose en 4 sesiones de 2 horas lectivas por semana.
7+
La duración del módulo es de 256 horas lectivas, a razón de **8 horas semanales**.
88

99
## Resultados de aprendizaje y criterios de evaluación
1010

11-
+ Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado.
11+
+ RA1: Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado.
1212

1313
| Criterios de evaluación |
1414
|-------------------------|
@@ -22,71 +22,68 @@ La duración del módulo es de 256 horas lectivas, a razón de **8 horas semana
2222
|Se ha comprobado el funcionamiento de las conversiones de tipo explícitas e implícitas.|
2323
|Se han introducido comentarios en el código.|
2424

25-
+ Escribe y prueba programas sencillos, reconociendo y aplicando los fundamentos de la programación orientada a objetos.
26-
+ Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.
27-
+ Desarrolla programas organizados en clases analizando y aplicando los principios de la programación orientada a objetos.
28-
+ Realiza operaciones de entrada y salida de información, utilizando procedimientos específicos del lenguaje y librerías de clases.
29-
+ Escribe programas que manipulen información seleccionando y utilizando tipos avanzados de datos.
30-
+ Desarrolla programas aplicando características avanzadas de los lenguajes orientados a objetos y del entorno de programación.
31-
+ Utiliza bases de datos orientadas a objetos, analizando sus características y aplicando técnicas para mantener la persistencia de la información.
32-
+ Gestiona información almacenada en bases de datos relacionales manteniendo la integridad y consistencia de los datos.
25+
+ RA2: Escribe y prueba programas sencillos, reconociendo y aplicando los fundamentos de la programación orientada a objetos.
26+
+ RA3: Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.
27+
+ RA4: Desarrolla programas organizados en clases analizando y aplicando los principios de la programación orientada a objetos.
28+
+ RA5: Realiza operaciones de entrada y salida de información, utilizando procedimientos específicos del lenguaje y librerías de clases.
29+
+ RA6: Escribe programas que manipulen información seleccionando y utilizando tipos avanzados de datos.
30+
+ RA7: Desarrolla programas aplicando características avanzadas de los lenguajes orientados a objetos y del entorno de programación.
31+
+ RA8: Utiliza bases de datos orientadas a objetos, analizando sus características y aplicando técnicas para mantener la persistencia de la información.
32+
+ RA9: Gestiona información almacenada en bases de datos relacionales manteniendo la integridad y consistencia de los datos.
3333

3434
<figure>
3535
<img src="img/coding.png" width="300" />
3636
</figure>
3737

3838
## Unidades didácticas / Temporalización
3939

40-
A continuación se muestran las unidades didácticas y una estimación temporal de cada una de ellas. El curso está dividido en 10 unidades didácticas distribuidas en tres trimestres.
40+
A continuación se muestran las unidades didácticas y una estimación temporal de cada una de ellas. El curso está dividido en 10 unidades didácticas distribuidas en tres evaluaciones.
4141

4242
### Primera evaluación
4343

44-
Compuesta por las 5 primeras unidades, donde se estudiarán los aspectos básicos de la programación orientada a objetos usando el lenguaje de programación **Java**.
44+
Compuesta por las 4 primeras unidades, donde se estudiarán los aspectos básicos de la programación orientada a objetos usando el lenguaje de programación **Java**.
45+
46+
|Unidad| Título |
47+
|------|------------------------------|
48+
| 1 | [Elementos de un programa informático](ud1/1elementos.md) |
49+
| 2 | [Estructuras básicas de control](ud2/1seleccion.md) |
50+
| 3 | [Programación orientada a objetos. Clases y Objetos](ud3/1metodoclase.md) |
51+
| 4 | [Arrays](ud4/1arrays.md) |
4552

46-
|Unidad| Título | Sesiones | Horas |
47-
|------|------------------------------|:--------:|:-----:|
48-
| 1 | [Elementos de un programa informático](ud1/1elementos.md) | 10 | 20
49-
| 2 | [Estructuras básicas de control](ud2/1seleccion.md) | 13 | 26
50-
| 3 | [Programación orientada a objetos. Clases y Objetos](ud3/1metodoclase.md) | 12 | 24
51-
| 4 | [Arrays](ud4/1arrays.md) | 9 | 18
52-
| 5 | [Herencia y polimorfismo](ud5/1herencia.md) | 14 | 28
5353

5454
### Segunda evaluación
5555

5656
Incluye 3 unidades y se profundizará en aspectos de codificación como colecciones de Java, interfaces de usuario, reflections, expresiones regulares, etc.
5757

58-
|Unidad| Título | Sesiones | Horas |
59-
|------|------------------------------|:--------:|:-----:|
60-
| 6 | [Colecciones](ud6/1list.md) | 15 | 30
61-
| 7 | [Programación avanzada](ud7/1generics.md) | 10 | 20
62-
| 8 | [Interfaces de usuario](ud8/1javafx.md) | 16 | 32
58+
|Unidad| Título |
59+
|------|------------------------------|
60+
| 5 | [Programación orientada a objetos avanzada](ud5/1herencia.md) |
61+
| 6 | [Colecciones](ud6/1list.md) |
62+
| 7 | [Programación avanzada](ud7/1generics.md) |
63+
6364

6465
### Tercera evaluación
6566

6667
Por último se aprenderán técnicas de lectura y escritura y persistencia de la información en ficheros y bases de datos.
6768

68-
|Unidad| Título | Sesiones | Horas |
69-
|------|------------------------------|:--------:|:-----:|
70-
| 9 | [Persistencia de la información](ud9/1io.md) | 13 | 26
71-
| 10 | Bases de datos | 16 | 32
69+
|Unidad| Título |
70+
|------|------------------------------|
71+
| 8 | [Interfaces de usuario](ud8/1javafx.md) |
72+
| 9 | [Entrada/Salida de la información](ud9/1io.md) |
73+
| 10 | [Persistencia de la información](ud10/1persistence.md) |
74+
7275

7376
## Instrumentos de calificación
7477

75-
<figure>
76-
<img src="img/qualification.jpg" width="300" />
77-
</figure>
78-
La nota de cada evaluación se calcula mediante:
79-
80-
- 30% Trabajo en Clase / Actividades
81-
- Se evalúan todas las actividades realizadas en clase y en casa.
82-
- Las actividades se evalúan mediante tareas de Aules con calificaciones comprendidas entre 0 y 3 puntos:
83-
- 0: No entregada.
84-
- 1: Entregada pero solución errónea o incompleta.
85-
- 2: Entregada y solución aceptable, aunque tiene algún apartado incompleto.
86-
- 3: Entregada y solución correcta.
87-
- Las actividades/prácticas son **fundamentales** para aprobar la asignatura.
88-
- Cualquier actividad que se detecte copia será puntuada con 0.
89-
- 70% Actividad de evaluación.
90-
- Se deben aprobar ambas partes por separado.
91-
92-
La nota final se calcula mediante la media de cada una de las evaluaciones.
78+
Como instrumentos de calificación se utilizan:
79+
80+
+ Desarrollo de programas
81+
+ Prototipos
82+
+ Memorias de resultados de prácticas
83+
+ Pruebas de evaluación que incluyen cuestionarios y/o ejercicios prácticos
84+
85+
## Evaluación
86+
87+
La evaluación se realiza utilizando los diferentes instrumentos de calificación vinculados con los criterios de evaluación de cada uno de los resultados de aprendizaje que sirven como indicadores del éxito alcanzado con ese RA.
88+
89+
Los RA tienen una ponderación específica que determina la nota final del módulo.

docs/ud3/8pojo.md

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
# 🌎 Valor nulo
2+
3+
Una variable de referencia contiene información sobre la ubicación de un objeto. No contiene el objeto en sí.
4+
5+
Por ejemplo el siguiente código:
6+
7+
```java
8+
String str;
9+
Persona p;
10+
```
11+
12+
declara dos variables de referencia pero no construye ningún objeto. Con el siguiente código:
13+
14+
```java
15+
str = "Programación";
16+
p = new Persona("Patricia");
17+
```
18+
19+
se construyen los objetos y se colocan referencias en las variables.
20+
21+
**_null_** es un valor especial que significa "sin objeto". Se establece una variable de referencia a _null_ cuando no se refiere a ningún objeto. Las variables a menudo se asignan en nulas cuando se declaran:
22+
23+
```java
24+
String str = null;
25+
Persona p = null;
26+
```
27+
28+
_str_ y _p_ todavía no son objetos, son variables que en un futuro pueden referenciar a objetos.
29+
30+
Podemos asignar el valor null a cualquier variable de tipo referencia, ya sea un objeto, string, array, etc.
31+
32+
Una variable de referencia a veces hace referencia a un objeto y otras veces no, y puede referirse a diferentes objetos en diferentes momentos. Por tanto, necesitamos una forma de decir que una variable ahora no se refiere a un objeto. Para ello, se le asigna un valor _null_ a la variable.
33+
34+
![Arrays](../img/ud4/nullvalue.png)
35+
36+
El objeto Persona con el nombre de Patricia se destruirá eventualmente por el _garbage collector_ ya que no es referenciado por nadie.

docs/ud7/6streams.md

Lines changed: 43 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,14 @@
11
# Streams
22

33
Los Streams fueron introducidos en Java 8 para abrir la puerta a la programación funcional al igual que con las expresiones lambda.
4+
No hay que confundirlos con los streams de entrada/salida, como un buffer stream de entrada o un fichero de salida.
45

5-
La API `Stream` permite manipular las colecciones como nunca antes. Nos permite realizar operaciones sobre la colección, como por ejemplo, buscar, filtrar, reordenar, etc.
6+
Según Oracle:
7+
8+
!!! Note
9+
**A stream is a sequence of elements supporting sequential and parallel aggregate operations.**
10+
11+
La API `Stream` permite manipular las colecciones como nunca antes. Nos permite realizar operaciones sobre la colección, como por ejemplo, buscar, filtrar, reordenar, etc. Pero no nos permite manipular los elementos individualmente en el flujo, sino que se trata el flujo como un todo, a menudo agregando o reduciendo los datos, o quizás contando o agrupando elementos de alguna manera.
612

713
Con Streams podemos utilizar cualquier clase que implemente la interfaz `Collection` como si fuese un `Stream` con la ventaja que nos ofrecen las expresiones lambda.
814

@@ -12,6 +18,16 @@ A través del API Stream podemos trabajar sobre colecciones como si estuviéramo
1218

1319
**Cada operación del stream debe verse como un paso independiente, es decir, no se puede usar variables intermedias**.
1420

21+
!!! Warning Importante
22+
Streams are lazy! Es decir, se inicia con la operación terminal, y los elementos de origen se consumen sólo cuando es necesario.
23+
24+
## ¿Cuándo querría utilizar Streams en vez de colecciones?
25+
26+
Los Streams son una interesante incorporación a Java, ya que me aportan varias ventajas:
27+
28+
1. Hacen que el código para procesar los datos sea uniforme, conciso y legible. Tiene una forma similar a SQL.
29+
2. Cuando se trabaja con grances colecciones, los flujos paralelos proporcionan una ventaja de rendimiento.
30+
1531
## Partes de un Stream
1632

1733
![Streams](../img/ud7/7streams.png)
@@ -34,6 +50,17 @@ La fuente proporciona los elementos a la tubería.
3450

3551
Las operaciones intermedias obtienen elementos uno por uno y los procesan. Todas las operaciones intermedias son perezosas (lazy) y, como resultado, ninguna operación tendrá ningún efecto hasta que la tubería comience a funcionar.
3652

53+
### Operaciones intermedias que tienen un efecto en el tamaño del stream resultante
54+
55+
| Tipo de retorno | Operación | Descripción |
56+
|-----------------|----------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
57+
| Stream<T> | distinct() | Elimina los valores duplicados del Stream. |
58+
| Stream<T> | filter(Predicate) | Los elementos que coinciden con el filtro de Predicate se mantienen en el stream de salida para las operaciones. |
59+
| Stream<T> | takeWhile(Predicate) | Similar a filter. Con la diferencia de que la primera vez que se evalúa a falsa la condición, deja de comprobar el resto de elementos. |
60+
| Stream<T> | dropWhile(Predicate) | Eliminará o filtrará cualquier elemento mientras coincida con la condición del Predicate. Cuando la condición se evalúa como falso la primera vez, la condición ya no se comprueba. |
61+
| Stream<T> | limit(long maxSize) | Reduce el stream al tamaño especificados en el parámetro. |
62+
| Stream<T> | skip(long n) | Este metodo omite elementos, es decir, no formarán parte del stream resultante. |
63+
3764
### `Peek()`
3865

3966
El método `peek` recibe como parámetro una expresión lambda de tipo `Consumer` para poder utilizar cada elemento del stream. Normalmente se utilizar para mostrar por consola el contenido del _stream_.
@@ -51,20 +78,10 @@ Stream.of("one", "two", "three", "four")
5178
.collect(Collectors.toList());
5279
```
5380

54-
### `Filter()`
55-
56-
Como su nombre indica lo que hacemos es filtrar de todos los elementos del _stream_ solo aquellos que cumplan una determinada condición.
57-
Recibe como parámetro una expresión lambda `Predicate` la cual debe devolver `true` solo en aquellos elementos que se quedarán en el _stream_ y `false` para aquellos elementos que se deben eliminar.
58-
5981
### `Sorted()`
6082

6183
Se utiliza para ordenar los elementos del _stream_. Recibe como parámetro una expresión lambda de tipo `Comparator` para que podamos indicar la lógica de la ordenación.
6284

63-
### `Distinct()`
64-
65-
Con `distinct` se seleccionan los elementos distintos dentro del _stream_ eliminando los duplicados.
66-
Los elementos se comparan utilizando el método equals().
67-
6885
### `Map()`
6986

7087
El método `map` recibe como parámetro una expresión lambda de tipo `Function`, por lo que debemos especificar una función que recibe como parámetro de entrada cada elemento del _stream_, y devuelve un objeto que puede ser un tipo de dato distinto o el mismo.
@@ -112,11 +129,11 @@ System.out.println(listOfAllIntegers);
112129

113130
Las operaciones terminales significan el final del ciclo de vida del steam. Lo más importante para nuestro escenario es que inician el trabajo en la tubería.
114131

115-
### `ForEach()`
132+
### `forEach()`
116133

117134
Recorremos cada elemento del _stream_ para realizar alguna acción con él. Como bien sabemos recibe como parámetro una exprsión lambda de tipo `Consumer`.
118135

119-
### `Collect()`
136+
### `collect()`
120137

121138
Es una operación terminal, se utiliza para indicar el tipo de colección en la que se devolverá el resultado final de todas las operaciones realizadas en el _stream_.
122139

@@ -125,28 +142,37 @@ List<String> lista = Arrays.asList("Texto1", "Texto2");
125142
Set<String> set = lista.stream().collect(Collectors.toSet());
126143
```
127144

128-
### `FindFirst()`
145+
### `findFirst()`
129146

130147
Se utiliza para devolver el primer elemento encontrado del _stream_. Se suele utilizar en combinación con otras funciones cuando hay que seleccionar un único valor del _stream_ que cumpla determinadas condiciones.
131148

132149
`findFirst` devuelve un objeto de tipo `Optional` para poder indicar un valor por defecto en caso de que no se pueda devovler ningún elemento del _stream_.
133150

134-
### `ToArray()`
151+
### `toArray()`
135152

136153
Con este método se puede convertir cualquier tipo de `Collection` en un array de forma sencilla.
137154

138-
### `Min()`
155+
### `min()`
139156

140157
Con `min` se obtiene el elemento del _stream_ con el valor mínimo calculado a partir de una expresión lambda de tipo `Comparator` que indicamos como parámetro.
141158

142159
`min` devuelve un objeto de tipo `Optional` para poder indicar un valor por defecto en caso de que no se pueda devolver ningún elemento del _stream_.
143160

144-
### `Max()`
161+
### `max()`
145162

146163
Con `max` se obtiene el elemento del _stream_ con el valor máximo calculado a partir de una expresión lambda de tipo `Comparator` que indicamos como parámetro de la expresión.
147164

148165
`max` devuelve un objeto de tipo `Optional` para poder indicar un valor por defecto en caso de que no se pueda devolver ningún elemento del _stream_.
149166

167+
### `anyMatch()`
168+
169+
El método `anyMatch` devuelve verdadero si al menos un elemento satisface la condición proporcionada por el predicado; en caso contrario, es falso. No evalúa el predicado sobre todos los elementos si no es necesario para determinar el resultado. El método devuelve verdadero tan pronto como se encuentra el primer elemento coincidente.
170+
Si la secuencia está vacía, se devuelve falso y el predicado no se evalúa.
171+
172+
| Sintaxis |
173+
| ----------- |
174+
| **boolean anyMatch(Predicate<? super T> predicate)** |
175+
150176
## Ventajas de Streams
151177

152178
- Código conciso y más limpio.

mkdocs.yml

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -36,14 +36,15 @@ nav:
3636
- 🖲️ Control de excepciones: ud2/24exceptions.md
3737
- 🖲️ Prueba y depuración de aplicaciones: ud2/25fallos.md
3838
- 🖲️ Introducción a los métodos en Java: ud2/26methods.md
39+
- ♾️ Recursividad: ud3/6recursion.md
3940
- 🌎 Programación orientada a objetos POO:
4041
- 🌎 Clases en Java: ud3/1metodoclase.md
4142
- 🌎 Constructores y destructores: ud3/2constructor.md
4243
- 🌎 Métodos y sobrecarga de métodos: ud3/3sobrecargametodos.md
4344
- 🌎 Paso de parámetros por valor y referencia: ud3/4referencevalue.md
4445
- 🌎 Variables, métodos y clases estáticas: ud3/5static.md
4546
- 🌎 Null value: ud3/7nullvalue.md
46-
- ♾️ Recursividad: ud3/6recursion.md
47+
- 🌎 POJO, Record: ud3/8pojo.md
4748
- 📅 Arrays:
4849
- 📅 Introducción: ud4/1arrays.md
4950
- 📅 Algoritmos útiles en arrays: ud4/2usefularrays.md
@@ -52,7 +53,7 @@ nav:
5253
- 📅 Algoritmos de ordenación: ud4/5sortarrays.md
5354
- 📅 Algoritmos de búsqueda: ud4/6searcharrays.md
5455
- 📅 Arrays multidimensionales: ud4/7twodimensionarray.md
55-
- Herencia y polimorfismo:
56+
- POO avanzada:
5657
- ✨ Herencia:
5758
- Concepto de herencia: ud5/1herencia.md
5859
- This vs super: ud5/1thisvssuper.md
@@ -107,7 +108,7 @@ nav:
107108
- 🧠 Mejora del rendimiento: ud10/6rendimiento.md
108109
- 🧠 Estructura de los proyectos: ud10/7projectstructure.md
109110
- 🔣 Atajos de teclado para IntelliJ: shortcuts.md
110-
- About : about.md
111+
- ❤️‍🔥 About me : about.md
111112
theme:
112113
name: material
113114
language: es

0 commit comments

Comments
 (0)