IntroducciónJava es un lenguaje de programación originalmente desarrollado por Sun Microsystems.

Este lenguaje tiene las características de ser de propósito general, está basado en clases, y es orientado a objetos.

Una de las mayores ventajas del lenguaje Java, es que es multiplataforma, es decir, que una vez hecho el programa, lo podremos ejecutar bajo cualquier sistema, sin necesidad de modificar nada.

Además Java tiene licencia GNU (ver más información aquí).

Podríamos hablar mucho más de Java, de todas sus versiones o características, pero como se trata de aprender a programar en Java, vamos a ir al grano y vamos a aprender a escribir código y crear nuestras propias aplicaciones.

Pero antes, tendremos que instalar todo lo necesario para programar en Java.

Instalando JavaLo primero y necesario es instalar Java en nuestro ordenador.

Esto servirá para que podamos ejecutar cualquier contenido Java en nuestra máquina.

Vamos paso por paso:

1-Entramos en http://www.java.com/es/download/ y pulsamos en: Descarga gratuita de Java.

2- Ejecutamos el archivo descargado. Y clicamos en "Instalar".

3- En la siguiente ventana, deseleccionamos la opción de instalar la Barra Ask y le damos a "Siguiente".

4- Esperamos al proceso de instalación...

5- ¡Todo listo! Cerramos la ventana que nos india que Java se instaló correctamente.

Ya tenemos Java instalado. ¿Fácil, no?

Pues ahora vamos con el entorno de trabajo.

Instalando Netbeans(Entorno de Trabajo)Ahora vamos a instalar el entorno de trabajo para programar en Java.

Hay muchos, pero en este curso vamos a utilizar Netbeans, que considero el más sencillo para empezar.

Entramos a: http://netbeans.org/downloads/index.html y pulsamos en "Download", donde nos indica la flecha.

1- Ejecutamos el archivo descargado, y nos aparece lo siguiente...Hacemos click en "Next".

2- Aceptamos los términos y continuamos: "Next".

3- Aceptamos los términos para la instalación de JUnit, y continuamos con "Next".

4- Ahora elegimos la ruta donde queremos que se instale Netbeans, es recomendable dejarla por defecto, tal como indica en la imagen:

5- En la siguiente ventana nos aparece toda la información de lo que vamos a instalar. Simplemente pulsamos en "Install".

6- Esperamos que se instalen todos los componentes...

7- ¡Listo! Deseleccionamos la opción de "Contribute to the Netbeans..." Lo dejamos tal cual está en la imagen, y le damos a "Finish".

Y ya está, eso es todo. Ya tenemos todo lo necesario para poder desarrollar en Java.

¿Listo para aprender a hacer tus propios programas en este lenguaje de programación? Vamos con ello.

Primer ProgramaVamos a dar ya los primeros pasos en programación propiamente dicha.

Para ello, abrimos el Netbeans: Botón Inicio de Windows, y seleccionamos Netbeans.

o bien, abriendo el acceso directo del escritorio...

Veamos ahora como realizar nuestro primer programa, lo más básico posible.

Lo primero será crear un nuevo proyecto, como vemos en la siguiente imagen:

En la ventana que nos aparece a continuación, dejamos todo tal como está por defecto, como se aprecia en la imagen:

Y en la siguiente ventana, le damos un nombre al proyecto, en este caso, AulaFacil (podéis poner el que queráis).

Ya tenemos creado el nuevo proyecto. Ahora vamos a escribir el código del programa.

Quedaría de la siguiente forma...

Lo único que tenemos que copiar es la línea: "System.out.println("Hola Mundo");".

El resto se crea solo. No te asustes por no entender todo lo que ves en pantalla, al principio es normal, pero poco a poco te harás con todos los conceptos de la programación.

En la siguiente lección vamos a explicar el código de este programa básico.

No obstante, por si os habéis perdido, dejo el vídeo que indica como lleva a cabo el proceso.

Explicación del ProgramaPasamos a explicar brevemente como funciona este programa simple.

No os preocupéis si no entendéis muchas de las cosas, puesto que al principio es normal, porque hay elementos que veremos más adelante.

Ahora solo quedaros con la función que desempeña dicho programa. No hace falta (en este momento) que se entienda todo al dedillo.

Bien, esto es lo que tenemos:

Hay que aclarar que el texto grisaceo, no se ejecuta, eso no lo interpreta Java como código a ejecutar, son comentarios orientativos para nosotros. (Se explicará bien en la siguiente lección).

Ahora vamos a analizar línea por línea:

package aulafacil; => Nos aparece por defecto, hay que dejarla tal cual.

Package es un conjunto de clases, y aulafacil, el nombre de ese package. (Ya iremos entendiendo como funciona todo esto más adelante).

public class AulaFacil { ... }=> Aquí se crea la clase principal.

Debe llevar el mismo nombre que le dimos al proyecto, en este caso, AulaFacil.

public static void main(String[] args) {// TODO code application logic hereSystem.out.println("Hola Mundo");}

Dentro de la clase AulaFacil, tenemos el método "main", es decir el método principal, que es el que se ejecuta cuando ejecutamos el programa.

O sea, todo lo que esté dentro de main ( {...} ), se ejecutará, en este caso, el "Hola Mundo" que tenemos debajo.

System.out.println no es más que una función del sistema, que escribe por consola lo que pongamos entre comillas, como es el caso del ejemplo.

Esto es, en general, todo lo que hay que explicar de este programa.

No entro más en profundidad porque hay conceptos que se adquieren más adelante durante el curso.

Ósea que no os preocupéis por no entender ahora que es una clase, o un método, o un package...Ya os iréis familirizando con ello a medida que avancemos en el curso.

¡Hasta la siguiente lección!

ComentariosLos comentarios son muy importantes en programación.

Ahora quizás no le veas mucha importancia porque es poco código lo que tenemos escrito, pero cuando haya muchas más líneas de código, hará falta tener comentarios a lo largo de todo el programa, para aclararnos bien con lo que estamos haciendo.

Y no solo nos servirá a nosotros, sino también si tenemos que pasar el código a alguien para que nos ayude o lo que sea, se podrá guiar con los comentarios.

Vamos a poner ejemplos:

Partiendo del programa que tenemos hecho de "hola mundo", eliminemos todo el código que está con letra gris (comentarios), así veremos como no cambia nada...Puesto que eso no se ejecuta.

Quedaría así:

Se puede comprobar, que si se ejecuta, tendremos el mismo resultado.

¿Como crear comentarios?

Muy fácil. Si queremos "comentar" una sola línea, lo hacemos poniendo delante lo siguiente: //

Esta barra diagonal se consigue pulsando: Shift + 7.

Si queremos comentar un trozo de código, para no tener que poner las barras por cada línea, lo podemos hacer fácilmente a través de Netbeans.

Tipos de datosEn cualquier lenguaje de programación, se trabaja con datos. Por ello, en esta lección voy a mencionar los tipos de dato más utilizados (y básicos).

Hay más, pero son menos útiles.

Los tipos de datos que más vamos a usar son los siguientes:

int = Tipo de dato entero. Su valor mínimo es -2,147,483,648 y el máximo 2,147,483,647 (incluído).

Ejemplo: 12, 456, -315...

double = Dato en coma flotante, para valores decimales.

Ejemplo: 2.40 - 3.14 - 10.90.

boolean = El tipo de dato boolean solamente tiene dos valores posibles: true (verdadero) y false (falso).

char = El tipo de dato char es un solo carácter Unicode. Por ejemplo: 'c', 'a', '7', etc..

Veremos otro tipo de dato sumamente útil, que son las cadenas de caracteres, pero a estas les dedicaremos una lección aparte.

Los tipos de datos no se pueden mezclar entre sí, es decir, no podemos introducir un dato tipo "double" en un dato tipo "entero", puesto que no tienen nada que ver.

Estos son conceptos puramente teóricos, ahora con el uso de variables (la siguiente lección), vamos a entender mejor para qué sirven los tipos de datos.

VariablesLas variables son el elemento esencial de la programación.

En ellas será donde almacenemos todos los datos con los que vamos a trabajar.

Vamos a aplicar los conceptos vistos anteriormente a la práctica, es decir, veremos como se crean y modifican datos en Java.

La creación de variables se lleva a cabo de la siguiente forma:

<tipo de dato> <nombre de variable>

El tipo de dato puede ser cualquiera de los vistos en la lección anterior, y el nombre de la variable, el que queramos darle, siempre es recomendable darle un nombre orientativo.

Como ejemplo, vamos a crear un dato de cada tipo visto anteriormente.

En la siguiente imagen veréis como queda:

En este caso, a la vez que los he creado, les he asignado un valor.

Esto también se podría hacer por separado, sería de la siguiente forma:

int num;num = 3;

De esta forma, primero se crea la variable tipo entero, y luego se le asigna el valor "3".

Ya solo nos queda comprobar que dichas variables tienen el contenido bien asignado. Para ello vamos a mostrar las variables por pantalla...¿Imagináis como? Como hemos hecho anteriormente, utilizaremos "System.out.println".

Esto nos mostrará el contenido de cada variable, como veremos en el vídeo a continuación:

Operadores AritméticosEl lenguaje Java soporta varios operadores aritméticos para los números enteros y en coma flotante.

Se incluye + (suma), - (resta), * (multiplicación), / (división), y % (módulo, es decir, resto de una división entera).

En la siguiente tabla se citan los operadores aritméticos:

Operador Uso Descripción+ op1 + op2 Suma op1 y op2- op1 - op2 Resta op2 de op1* op1 * op2 Multiplica op1 por op2/ op1 / op2 Divide op1 entre op2% op1 % op2 Calcula el resto de dividir op1 entre

op2

Los operadores son los ya conocidos de siempre, se suelen estudiar de pequeño en matemáticas. Aquí funcionan igual.

Vamos a ver un ejemplo en lo que nos concierne, que es la programación en Java.

¿Qué debería mostrar este programa por pantalla?

Seguro que ya lo has averiguado. ¡Compruébalo!

Ejercicios n° 1A lo largo del curso, voy a ir introduciendo ejercicios, para que vayáis poniendo en práctica todo lo aprendido anteriormente.

Porque por más teoría y práctica que se explique, cuando realmente se aprende a programar es programando, no hay otra opción más fiable que esa.

A continuación, os propongo el enunciado del ejercicio:

Escribe un programa con 3 variables, en el cual dos de ellas tengan los valores 20 y 10. El programa tiene que mostrar por pantalla el resultado de:

- La suma de ambos números. - La multiplicación.- La división.

Recuerda que sólo puedes utilizar 3 variables en este ejercicio.

La solución se encuentra en la siguiente lección, pero antes de mirarla, intenta crear el programa por ti mismo, que es como realmente vas a aprender.

El resultado del programa es el siguiente

¡Ánimo!

Solución al Ejercicio° 1

¿Has sido capaz de crear el programa por ti mismo? ¡Muy bien! Aquí tenemos la solución...

Dividiremos el código en 2 partes, para que sea más comprensible. Primero, creamos las variables y le asignamos los valores

Y ahora, debajo de todo esto, tenemos que hacer las operaciones con esas 2 variables, así:

Como véis, la variable "resultado" va cambiando de valor, o sea, su valor se va machacando.

Los comentarios del programa aclararán mejor lo que se está haciendo con cada instrucción o línea de código.

Primero obtiene la suma, luego la muestra, y debajo, cambia el valor de la suma, por el de la multiplicación, se sobrescribe esa variable, y así sucesivamente...

Leer datos por tecladoAhora, imaginemos que los números que vamos a utilizar, en vez de decidirlo nosotros mismos, le damos la opción al usuario de que los decida.

Es decir, en vez de utilizar los valores 20 y 10 como anteriormente, le pedimos al usuario que introduzca los números que quiera...

Para leer datos por teclado en Java, se hace de la siguiente manera, a continuación la imagen del código.

He puesto flechas en las zonas donde hay código que se va a explicar ahora.

import java.util.Scanner; => Lo que hace esta línea no lo entenderéis hasta que no se avance en el curso, por lo pronto, ponedla sin más, porque es necesaria para la lectura de datos por teclado.

Los "import" se explicarán más adelante, a su debido tiempo.

Scanner leer=new Scanner(System.in); => Aquí se crea la variable "leer", que es del tipo "Scanner".

Realmente, Scanner es una clase, y se está creando un objeto de dicha clase.

Esto tampoco se va a entender bien, hasta que no se expliquen las clases con detenimiento (más adelante).

num=leer.nextInt(); => Se asigna el valor dado por teclado a la variable tipo entero "num".

Hay que dejar claro, que si la variable fuese por ejemplo tipo "double", entonces esta línea debería escribirse así: num=leer.nextDouble(); Para que lea un valor tipo Double.

Os animo a realizar el ejercicio anterior, pero que esta vez los valores se introduzcan por teclado, en vez de utilizar los valores preestablecidos del 20 y el 10. Modificando un par de líneas se puede hacer.

Simplemente hay que cambiar la parte de asignación de las variables, y poner el código que habéis aprendido en esta lección.

¡A practicar!

FuncionesLas funciones, como su propio nombre indica, se encargarán de hacer una "función" concreta de nuestro programa.

El sistema ya tiene muchas funciones establecidas, pero tu mismo también puedes crear funciones.

Por ejemplo cuando mostramos algo por pantalla, estamos utilizando la función del sistemaSystem.out.println.

Vamos a suponer, que queremos mostrar el "Hola Mundo" cada vez que queramos y de forma fácil, podemos hacer lo siguiente:

.

De esta forma, cada vez que quisieramos escribir el "Hola Mundo", nos bastaría con llamar a la función, y no lo tendríamos que hacer varias veces. Esa es la idea de las funciones.

Esta función que hemos hecho es para entenderlo a modo explicación, pero no es muy útil que digamos.

Hay más tipos de funciones

.

Reciben datos y no devuelven nada No reciben datos y no devuelven nada. (La que hemos visto en el

ejemplo) Reciben datos y devuelven datos.

Vamos a ver un ejemplo de una función que recibe datos y no devuelve nada.

Esta función muestra el número que le pasemos entre los paréntesis. Los datos que recibe una función se llaman parámetros.

Fijaos que dentro de la función la variable se llama "numero", pero contiene el valor de "num". Esto se entenderá en la siguiente lección, el ámbito de las variables.

El último tipo de función que nos falta por ver son las que reciben datos y devuelven un dato.

Vamos a realizar una función que sume dos variables pasadas por parámetro.

En la creación de la función, hemos cambiado el void por int...Void significaba que no devolvía ningún valor, y como esta vez devuelve un número entero, ponemos int.

Si devolviera un tipo double pues escribiríamos double.

Para devolver el valor, tenemos que utilizar la palabra return, como veis en la función.

El resultado se muestra en pantalla a través de la siguiente línea:

System.out.println("El resultado de la suma es: " + Suma(num1, num2));

Cuando escribimos Suma(num1, num2), realmente es como si estuvieramos escribiendo una variable tipo "int", porque es lo que devuelve la función.

Todo este tema de las funciones puede parecer un poco lioso al principio, tendrás que ir familiarizándote con su uso poco a poco. Al principio son difíciles de entender.

Con la próxima lección te puedes aclarar un poco mejor.

Ámbito de las variables y constantesEl ámbito de las variables es muy importante en cualquier lenguaje de programación. Esto se refiere al uso de una variable.

Depende de donde creemos una variable, la podremos utilizar en un lugar u otro.

El ámbito de una variable puede ser global, o local.

Vamos a ver ejemplos de variables locales:

Las variables locales como veis, solo se pueden utilizar en el ámbito en el que las creamos.

Es decir, la variable local_funcion, solo la puedo utilizar en la función donde la he creado, no fuera de ella.

Por eso si la intento utilizar en el "main", Java me detecta un error.

Lo mismo ocurre al contrario, las que he creado en "main" no las puedo utilizar en la función directamente, para eso están los parámetros.

Ahora bien, si queremos utilizar una variable a lo largo de todo el programa, en cualquier función y donde sea, podemos crear variables globales.

Así se crean variables globales: static int global;

Tienen que estar situadas donde veis en la imagen, sino no serán variables globales.

De todas formas Netbeans te auyda poniéndolas en verde, para que se sepan que son variables globales, que son las que se pueden utilizar en cualquier sitio, en cualquier ámbito.

Hay otro tipo de variables muy útiles que son las variables CONSTANTES. Estas variables toman un valor, y ese valor que ha tomado será siempre el mismo durante toda la ejecución del programa.

Su utilidad es por ejemplo, para días de la semana, que son 7, y nunca serán más ni menos.

Entonces, podemos crear una variable constante, que sea días de la semana. Vamos a ver como hacerlo:

Así se declaran las constantes: static final int DIAS_SEMANA = 7;

static final <tipo_variable> <nombre_constante> = <valor>

Otra constante posible sería:

static final double PI = 3,14;

¿Se entiende? ¡¡¡Vamos a la siguiente lección!!!

Ámbito de las variables (2)Continuamos con este tema, ya que es importante tener los conceptos claros en este aspecto.

Vamos a poner un ejemplo que ilustre bien todo lo se trata de ámbito de variables. Pondremos la imagen e intentaréis averiguar el valor de la variable en cada flecha donde lo indique.

Ahí va:

Pregunta 1: n vale 2

Explicación: num se le asigna el valor 2, y cuando se llama a la función, se le pasa num (o sea, el valor 2).

El parámetro de la función "n", recoge el valor que le pasamos, o sea 2.

Pregunta 2: n vale 10

Explicación: El valor de "n" se machaca, y se le asigna un 10.

Por eso si mostramos la variable después de la asignación, valdrá 10.

Pregunta 3: num vale 2

Explicación: "num" empieza valiendo 2. Y luego en la llamada a la función, se le pasa por parámetro el valor de "num", que es 2.

Dentro de la función se modifica "n" y se pone en valor 10, pero esto no afecta para nada a la variable "num", ya que está en otro ámbito.

De ahí que siga valiendo 2, como al principio.

Cadena de caracteresLas cadenas de caracteres son un tipo de dato muy utilizado. Para crear una cadena, lo haremos a través de la clase String que nos ofrece Java.

En este momento nos vale con entender su uso y funcionalidad. Más tarde entenderemos el resto (cuando se expliquen las clases y objetos).

De esta forma se crean cadenas, es como un tipo de variables cualquiera en un principio, aunque al ser "String" ya veremos qué tienen de particular.

Como he dicho antes, los "String" es una clase de Java, por ello cuando yo creo una variable de este tipo, tenemos dentro de esta variable, una serie de métodos que nos ofrecerán información de esta variable.

Vamos a poner algún que otro ejemplo para que lo entendáis:

En Netbeans, vemos como cuando escribimos:

cadena

Nos aparece una lista con todos los métodos de esta cadena. En este ejemplo, he escogido la de "length", la cual devuelve un entero (la longitud de la cadena), el método funciona como una función.

Length, hace el recuento de esta cadena (del "hola mundo") y me devuelve la longitud, en este caso, 10, ya que el espacio en blanco también cuenta como un caracter.

Hay muchísimos métodos que podemos usar, pero sería engorroso verlos todos.

Vamos a ver otro más, el resto ya sería ir probando y trasteando con ellos, depende lo que nos haga falta...Veamos ahora el método replace.

A la hora de mostrar la cadena, le hago un "replace", y le paso dos parámetros.

El primer parámetro es la letra a reemplazar, y el segundo la letra por la que quiero que sea reemplazada.

Ese método lo que hace es reemplazar todas las letras 'o' que haya en la cadena por la letra 'a'.

El resultado de la muestra de la cadena es: "Hala Munda".

Sentencias IfEn esta lección veremos la sentencia IF. Muy importante saber su funcionamiento, puesto que se utiliza en todos los lenguajes de programación.

La sentencia IF no es más que una sentencia condicional, o sea, que si se cumple "x" condición, el programa hace una cosa, y si no se cumple, el programa hace otra.

Mirad la siguiente imagen:

Este programa solo muestra algo por pantalla, si el valor que has introducido es menor o igual que 5.

Las sentencias IF se construyen de la siguiente forma:

if (condición)

{instrucciones...

}

Dichas instrucciones solo se ejecutarán si se cumple la condición del IF.

En el ejemplo que he puesto es n <= 5. Bien, estos operados que he utilizado para la condición, son operadores de comparación.

Los operadores de comparación son los siguientes:

Operador Uso Devuelve verdadero si> op1 > op2 op1 es mayor que op2

>= op1 >= op2 op1 es mayor o igual que op2< op1 < op2 op1 es menor que op2

<= op1 <= op2 op1 es menor o igual que op2

== op1 == op2 op1 y op2 son iguales!= op1 != op2 op1 y op2 son distintos

Esos son los distintos operadores que se pueden utilizar para comparar.

Y estaréis pensando..¿y si no se cumple la condición del IF?

Para eso está el "else", que significa "si no...". Vamos a añadirle al programa ese "else".

Ahora el programa, si no introduces un número menor o igual a 5, ejecutará las instrucciones que estén dentro del "else".

Por si todo ha resultado un poco lioso, vamos a rematar la lección con un vídeo de demostración.

Sentencias If (2)Aún queda algo por ver de las sentencias IF. Más concretamente en la parte de la condición del IF.

En el ejemplo anterior, vimos que si se cumplía la condición, entonces se ejecutaba lo que había dentro de ese IF, y sino, se ejecutaba el else (en caso de haberlo).

Pues ahora vamos a ver como poner condiciones más particulares por decirlo así.

Podemos poner más de una condición. Esto se lleva a cabo con los operadores condicionales.

Vamos a poner un ejemplo:

Fijaos en la sentencia IF, ahora la condición es la siguiente:

n <= 5 && n >= 2

Son dos condiciones a la vez. El operador "&&" significa "Y". Es decir, la condición es la siguiente: Si 'n' es menor o igual que 5 y también n es mayor o igual que 2...

Los operadores condicionales son los siguientes:

Operador Uso Devuelve verdadero si...

&& op1 && op2 op1 y op2 son ambos verdaderos, condicionalmente evalúa op2

|| op1 || op2 op1 o op2 son verdaderos, condicionalmente evalúa op2

! ! op op es falso

Si en vez de "&&" utilizamos el operador "||", la condición sería:

n <= 5 || n >= 2

Si n es menor o igual que 5 o n es mayor o igual que 2. En este caso, la condición se cumple al ser verdadero una de las dos partes, cualquiera de ellas.

Para este ejemplo es un poco absurda esta condición, ya que un número siempre va a ser igual o menor que 5 o mayor o igual que 2.

Es una condición que se cumplirá siempre, como podréis comprobar al ejecutar el programa.

Tendría más sentido algo así:

n <= 2 || n >= 9

Si n es menor o igual que 2 o n es mayor o igual que 9. Ahora por ejemplo si metemos el número 6, no se cumple la condición...

SwitchTambién existen ocasiones o programas donde se exige evaluar muchas condiciones a la vez, en estos casos, o se usan una condición compuesta muy grande o se debe intentar convertir el problema a uno que se pueda resolver usando la instrucción switch();

Esta instrucción es muy útil por ejemplo si vamos a hacer un menú. Por ejemplo:

Aquí hemos creado un menú. Simplemente hemos hecho que se nos muestre por pantalla, y"n" va a leer la opción que introduzcamos por teclado.

Después de este código es cuando viene el switch.

Se escribe así:

switch (n) => Entre paréntesis ponemos la variable que vamos a utilizar para la instrucción, en este caso es "n".

case 1:

System.out.println("Has elegido la opción 1");break;

Para cada opción, tenemos que escribir este código.

Lo primero es "case", y seguidamente el valor de la variable...(Es como si fuera IF (n == 1).

Y dentro del case, lo que queremos que ocurra en caso de tomar la opción número 1.

Al final de las instrucciones que queramos, le añadimos el "break", es necesario para que una vez realizada la opción elegida, salga del switch.

Para cada caso que necesitemos escribiremos el "case" que hemos visto. Pero hay una opción diferente, como véis, que es el "default", significa para todo lo demás.

O sea, que si no se cumple ningún "case", se ejecutará el default.

Bucles -WhileLa sentencia "While" existe en la mayoría de lenguajes de programación, y es algo que hay que saber si o si para el aprendizaje de la programación.

El propósito de los bucles es hacer que se ejecute un fragmento de código (el que esté dentro del While), mientras una condición sea verdadera.

La forma de escribirlo es muy similar a la de un IF, es muy sencilla:

n comienza inicializada en 0.

Entonces la condición del While "pregunta"...¿n es menor o igual que 10?

Si, es menor, entonces ejecuta lo que hay dentro del While.

Muestra por pantalla el valor de "n", o sea 0. Luego incrementa "n" a 1, o sea que "n" vale 1.

Y ahora se vuelve a preguntar...¿n es menor o igual que 10? Si, pues vuelve a entrar al While...hasta que "n" no sea menor o igual que 10.

¿Cual creéis que será el resultado de este programa?

Lo que hace es, mostrar los números del 0 al 10, simplemente.

Hay que aclarar la línea de: n++

Los "++" es un operador de incremento, lo único que hace es aumentar el valor de esa variable en 1.

Es decir, si "n" vale 0, se pone en 1, si "n" vale 3, se pone en 4...y así.

También está la posibilidad de rebajar un valor, con el operador "--"

***IMPORTANTE***: Es muy común cuando se esta empezando, cometer un error en este tipo de bucles.

Los bucles While SIEMPRE tienen que modificar los valores de la condición...En este caso, la "n", dentro del bucle se tiene que modificar...porque si no nunca va a ser falsa la condición, y por tanto se producirá un bucle infinito.

Bucles - ForComo bien indica el título de esta lección, las sentencias For, también son bucles. Este tipo de bucles tiene particularidades con respecto al While. Vamos a ver su funcionamiento:

Si os fijáis en el ejemplo del While, teníamos que inicializar la variable "n" antes del bucle, y luego incrementar esa variable dentro del bucle...Pues en el caso del For se hará todo de inmediato. Veamos el formato del For en este ejemplo:

Como vemos, en el propio For, se inicializa la variable, y se incrementa, y entre medias, se escribe la condición.

for (inicialización ; condición ; incremento / decremento de variable)

Esa sería la estructura de los bucle For.

Este programa, como podréis imaginar, realiza lo mismo que el otro, mostrar los números del 0 al 10.

Ejercicio (nº 2)Para que vayas aprendiendo más rápidamente, te proponemos un ejercicio más complejo que el anterior y que utilice los nuevos conceptos aprendidos:

El enunciado del ejercicio es el siguiente:

El programa debe mostrar un menú con las siguientes opciones:

1. Función: mostrarNumeros() -- Mostrar los números por pantalla desde el 0, hasta un número introducido por teclado. (Ejemplo: si introduzco el número 12, que se muestre por pantalla desde el 0 hasta el 12.

2. Función: Edad() -- Pedir un número al usuario, y comprobar si este es mayor o menor de edad. (Ejemplo: Si introduce 12, el programa te devuelve que NO es menor de edad...Y si introduce un número mayor a 18, que te avise de que SI eres mayor de edad).

Ese es el menú que debe presentar el programa. Cada opción se tiene que desarrollar a través de una función.

Es decir, la primera tiene que ser una función que haga todo el proceso, y la segunda igual, una función que haga la comprobación de si eres o no mayor de edad.

En el menú, cuando elijas un número, llamas a dicha función y ya está.

Como siempre, te animamos a que lo intentes por ti mismo antes de mirar la solución.

¡Ánimo!

Solución Ejercicio (nº 2)Voy a mostrar la forma que he llevado a cabo para la solución de este ejercicio.

En programación hay muchas maneras de hacer las cosas, pero creo que esta es una de las más sencillas para este ejercicio concreto.

Este ejercicio consta de 3 partes; las dos funciones y el menú.

Voy a mostrar primero las dos funciones, y luego el menú (que se crea en el "main") como ya sabréis.

1.- Función: mostrarNumeros()

2.- Función: Edad()

Eso en cuanto a las funciones...¿Las lograste hacer correctamente? Aunque no lo hayas conseguido, viendo ahora la solución también se aprende.

Ahora vamos a ver el menú...Que no es más que un Switch, que elige entre el 1 o el 2, y hace llamadas a dichas funciones.

Todo esto es el código que se pedía en este ejercicio. Como ya dije, puede que lo hayas llevado a cabo de otras formas.

Ahora bien, esto tiene un pequeño "problema". Y es que el programa se ejecuta, y elige una opción del menú, se realiza esa función y ya termina...

Lo ideal sería que cuando termine de hacer dicha función, nos lleve de nuevo al menú a elegir opción de nuevo ¿no?

Vamos a añadirle unas líneas más de código para conseguirlo. Como estarás imaginando, esto se hace con el uso de bucles...

De esta forma conseguimos que salga el menú siempre, hasta que introduzcamos la opción 3.

No olvides inicializar la variable "op" y ponerla a 0. (En realidad vale cualquier valor que no sea 3).

ArrasysUn array es un medio de guardar un conjunto de objetos del mismo tipo.

Se accede a cada elemento individual del array mediante un número entero denominado índice.

0 es el índice del primer elemento y n-1 es el índice del último elemento, siendo n, la dimensión del array.

Para crear un array se hace así:

int[] numeros;

Con esa línea se crea la variable tipo Array.

Eso si, ahora hay que darle un índice, para saber de cuántos elementos se compone el Array.

numeros = new int[5];

Así "rellenamos" al Array de 5 elementos. Es decir, es como si tuvieramos 5 variables "int" todas juntas.

Veamos un ejemplo donde tenemos un Array de 5 elementos y le damos un valor a cada elemento, y los mostramos por pantalla...

Así se le asignan valores a los elementos:

numeros[0] = 23; => Lo que hay entre [] es el índice. No puede ser mayor que 4, en este caso.

Si el Array fuera de 10 elementos, no podría ser mayor que 9 su índice.

Luego se muestran por consola con el System.out.println, como siempre.

Pero ¿qué problema hay en todo eso? Pues que imagina que tenemos un Array de 200 elementos...¿No sería un poco engorroso mostrar los elementos? Costaría mucho trabajo además.

Pues bien, la solución es utilizar un bucle For, para los Arrays son ideales.

Veamos como mostrar todos los elementos del Array de forma fácil.

Fijaos en el bucle For. La condición es: Si "i" es menor que numeros.length (números.length es un entero que nos dice el tamaño de ese Array, en este caso 5). O sea si "i" es menor que 5, se ejecuta el For.

Y se muestra numeros[i]...Ya que "i" va a empezar en 0, y luego va a ir subiendo hasta 4, por lo tanto, el bucle recorre todo el Array.

De esta forma, sea el Array de 10, de 200, o de 56999 elementos, el For de este tipo, siempre recorrerá el Array completo.

Arrays MultidimensionalesComo su propio nombre indica, son Arrays de más de una dimensión. Vamos a ver los de 2 dimensiones.

Su funcionamiento es el mismo que el de los Arrays de una sola dimensión, lo que pasa que estos están compuestos por filas y columnas.

Una imagen ilustrativa para que se entienda:

La estructura para declarar un Array multidimensional es la siguiente: int [filas][columnas]

Vamos a ver un ejemplo:

Esta es la forma de acceder y recorrer todo el Array, con dos For anidados. Lo que hace este programa es poner todos los elementos del Array a 0.

¿Como se podría comprobar esto? Pues mostrando por consola todos los valores del Array. Para ello, necesitamos de nuevo hacer los dos For anidados.

Debajo de todo este código, escribimos estos dos bucles para mostrar el Array multidimensional.

Con esto conseguimos mostrarlo por consola, y de esta forma:

Programación orientada a objetos (POO)Hasta ahora todo lo que hemos visto, son cosas generales de lenguajes de programación.

Pero ahora entramos en el tema de "programación orientada a objetos" que es uno de los conceptos que hacen 'especial' a Java.

La programación orientada a objetos trata de amoldarse al modo de pensar del hombre y no al de la máquina.

El elemento básico de este paradigma no es la función (elemento básico de la programación estructurada), sino un ente denominado objeto.

Un objeto es la representación de un concepto para un programa, y contiene toda la información necesaria para abstraer dicho concepto: los datos que describen su estado y las operaciones que pueden modificar dicho estado, y determinan las capacidades del objeto.

Java incorpora el uso de la orientación a objetos como uno de los pilares básicos de su lenguaje.

Una de las principales características de la programación orientada a objetos es la abstracción:

Abstraer significa simplificar.

A partir de ahora en adelante vamos a trabajar con clases y objetos, que son el elemento principal del lenguaje Java (y cualquier lenguaje orientado a objetos).

Al principio se puede hacer un poco difícil de entender, pero con constancia y empeño se entenderá y veréis como la programación orientada a objetos ofrece muchísimas ventajas.

Como siempre, lo ideal es aprender con la práctica.

¡Así que vamos a ello!

ClasesEl elemento básico de la programación orientada a objetos en Java es la clase.

Las clases definen una estructura de datos, que servirá de "plantilla" para todos los objetos que hagamos de esa 'clase'.

Dicho así es difícil de entender, vamos a poner un ejemplo de la vida cotidiana.

La Clase Coche digamos que es como la "plantilla". Y luego, a la hora de crear los coches (recuadros azules) se le asignan los valores que queramos para cada coche.

Los coches son los Objetos de dicha Clase.

La clase Coche tendrá una serie de características que le indicaremos nosotros por código.

Entonces, a la hora de crear los coches (cuadros azules), todos compartirán esas características, como pueden ser marca, color, etc...

Por ejemplo:

Lo que pasa que a cada coche, se le asignarán las características propias.

Todo se irá entendiendo mejor cuando trabajemos con las clases en Netbeans.

En la siguiente lección vamos a escribir nuestra primera clase.

Creando la Clase CocheSin más teoría, vamos a ponernos manos a la obra para crear una clase propia. Lo haremos lo más sencillita posible con el fin de entender el funcionamiento de las clases.

Lo primero, va a ser crear un archivo nuevo, una clase Java:

Una vez elegimos la opción "Java Class", nos saldrá la siguiente ventana:

Lo único que tenemos que poner aquí es el nombre de la Clase. Por norma general, la primera letra del nombre la pondremos en mayúscula.

Pulsamos en "Finish" y listo.

El archivo se nos crea correctamente y nos aparece lo siguiente:

Ya tenemos el archivo necesario para trabajar en nuestra nueva Clase llamada Coche.

Un vídeo demostrativo de como crear la Clase:

Atributos de la ClaseLos atributos de una Clase son aquellas variables que compartirán todos los objetos que creemos de esta Clase.

En este caso, tenemos la Clase Coche, pues vamos a añadirle atributos pertenecientes a un coche.

Para no alargarlo mucho, creamos solo 3 variables (pueden ser las que creamos convenientes), depende del problema en cuestión.

Así se crean los atributos de la Clase:

Las variables de la Clase se declaran como variables normales, como ya hemos hecho anteriormente. Pueden ser de cualquier tipo.

Lo que pasa que al ser variables de una Clase (atributos) tienen una peculiaridad. Si os fijáis le hemos delante la palabra private.

Esto es para que los atributos de esta Clase sean "privados". Eso significa que no se pueden modificar desde otras Clases, solo desde la Clase propia. (Ya veremos como hacerlo a través de MÉTODOS).

Si queremos acceder a estos atributos desde otras Clases, en vez de "private" escribimos: public.

Generalmente siempre se ponen las variables privadas.

ConstructorEl constructor siempre tiene el mismo nombre que la Clase y se utiliza para construir objetos de esa Clase.

Los constructores no tienen ningún valor de retorno, ni siquiera "void".

Los constructores se forman así:

El constructor si lleva delante la palabra public.

Si os dáis cuenta es muy parecido a una función. Lo que pasa que el constructor no tiene valor de retorno, no es necesario.

Porque lo que hace esta Clase al llamar a su constructor es crear un objeto de la Clase.

Fijáos como le pasamos por parámetros las variables necesarias para la "creación" del coche.

Es decir, cada que vez queramos crear un nuevo Coche, por parámetro hay que pasarle la marca, color, y km, para que se asignen esos valores a los atributos de la Clase.

Como digo siempre, esto es difícil de entender ahora porque es un poco abstracto, pero más adelante cuando utilicemos la Clase Coche, y empecemos a crear Objetos de la Clase, se va a ir comprendiendo todo mucho mejor.

MétodosLos métodos son como una Función (visto anteriormente en la lección 13).

 

Lo que pasa que los métodos están dentro de una clase, es decir, que son funciones que solo utilizan los objetos de esta Clase, en este caso, los coches que creemos.

 

Se pueden hacer tantos métodos como se quieran para la Clase.

 

En esta Clase Coche, vamos a crear solo 3, que son los siguientes:

 

o Método para añadir más Km al coche.o Método para saber cuántos Km lleva recorrido el coche.o Método para saber de qué color es el coche.

 

Como ya digo, se pueden hacer más, por ejemplo, un método para saber qué marca es el coche, otro para modificar el color del coche, etc...Pero con estos 3 nos valdrá para aprender a crear los métodos, que es lo que nos interesa, y esto es una Clase de ejemplo.

 

Debajo del constructor de la Clase, vamos a programar los métodos, de esta forma:

 

 

 

El primer Método, le suma la cantidad que le pases por parámetro, a la cantidad de Km que ya tenía el coche.

 

El segundo, simplemente devuelve los Km que tiene el Coche.

(Esta es la forma de acceder a las variables "private", si fuese "public", no tendríamos que hacer este método, puesto que se podría acceder a la variable directamente).

 

Y el tercero, realiza la misma operación que el segundo. Este tipo de métodos son muy comunes en las Clases.

 

Y con esto terminamos la Clase de ejemplo. En el siguiente vídeo veréis como ha quedado la Clase al completo.

Objetos

Pues bien, ya hemos terminado de programar nuestra Clase Coche. Ahora, vamos a darle utilidad a dicha Clase.

Los objetos son instancias de esa Clase.

Es decir, que todos los Objetos que creemos del tipo "Clase Coche", van a tener las mismas variables y métodos, porque como ya hemos visto, todos comparten esa 'plantilla', por llamarlo de alguna manera.

Ahora vamos a trabajar sobre el archivo AulaFacil.java, en el MAIN.

Veamos como funciona esto:

Así se crean Objetos de la Clase Coche.

Coche es el "tipo de dato" por eso es lo primero que se pone, luego va el Nombre de la variable, en este caso son 'c1' y 'c2'.

Fijaros en los parámetros con los datos del Coche...¿Qué son esos parámetros?

Esos parámetros son los que nos pide el Constructor de la Clase. En este caso era así:

public Coche (String m, String c, double kilometros)

Nos pide 3 valores, los dos primeros Cadenas de caracteres, y luego un valor numérico, que son los Km.

Para el paso por parámetro: Los valores que sean tipo String se pasan entre comillas, y los númericos sin comillas, como vemos en el ejemplo.

Cada vez que queramos crear un Objeto Coche, tenemos que darle esos valores (Hay que ceñirse al Constructor). Más adelante veremos como crear diferentes Constructores de una Clase.

Ahora bien, si escribimos por ejemplo: c1. nos aparecerán todos los métodos que pertenecen a esa Clase Coche. Se ve el ejemplo con esta imagen:

Los 3 primeros que están en negrita vemos que son los métodos que creamos para dicha Clase.

Para acabar esta lección, vamos a utilizar un par de métodos. Que quede claro que tanto para c1 como para c2 existen los métodos. (Y con todos los Objetos que creemos de la Clase Coche, obviamente).

Añadimos las siguientes líneas a lo que ya tenemos:

A través de los métodos mostramos los Km de cada coche. Luego añadimos 50 Km más al Coche uno, y por último volvemos a mostrar los Km del Coche 1, para comprobar que se ha modificado su valor.

El resultado es el siguiente:

Ejercicio (nº 3)De nuevo llegamos a la realización de otro ejercicio. En este caso se trata de construir una nueva Clase, pero lo vais a tener que hacer desde 0 vosotros mismos.

Con eso conseguiréis coger más soltura con la programación orientada a objetos, que es de lo que se trata.

Ahí va el enunciado de lo que tenéis que hacer:

Crear una Clase llamada Persona, con la siguiente estructura:

-Los atributos de la Clase Persona son: Nombre, edad, dni y descripción.

-Al crear cada Persona, se le debe pasar por parámetro su nombre y edad solamente.

-Debes realizar los siguientes Métodos:

Introducir DNI (String d): Método que introduce el dni de la persona

Introducir Descripción (String desc): Método que introduce la descripción de la persona

Cambiar Edad (int num): Método que cambia la edad actual de la persona, por la edad introducida por parámetro.

Mostrar Datos (): Método que muestra los datos de la persona en cuestión.

Y eso es todo. Seguro que puedes llevarlo a cabo. Ya sabes que cuando termines el ejercicio, puedes comprobar la solución en la siguiente lección.

Solución Ejercicio (nº3)

Como viene siendo habitual, aquí os traigo la solución al Ejercicio nº 3. Espero que lo hayáis realizado antes de mirarlo, puesto que así aprenderéis más, practicando.

La verdad que era muy similar a la otra Clase que ya habíamos creado anteriormente (Clase Coche), así que imagino que lo habréis llevado a cabo sin muchos problemas.

Veamos como queda la Clase Persona, la dividiremos en dos partes, primero mostraré el código de los atributos y constructor, y luego los métodos.

El paso de crear el archivo Persona.java lo obviamos, directamente muestro el contenido del archivo:

Véase como el Constructor recibe 2 parámetros, el de Nombre y Edad de la Persona, tal y como nos indicaba el enunciado del ejercicio.

Y ahora, bajo este código, vienen los métodos...

Con esto, ya tenemos creada la Clase Persona. Por último vamos a ver el vídeo en donde mostramos como nos queda todo el código.

Packages e importsLos Packages son un agrupamiento de clases con características comunes.

Todas las Clases que tenemos creadas en este proyecto "AulaFacil", pertenecen al package de "aulafacil", como bien nos indican al principio de cada archivo.

Todos los archivos que creamos dentro de "aulafacil" pertenecen al mismo Package.

Por lo tanto, tenemos las Clases Coche y Persona en ese mismo Package.

Vamos a crear otro Package para que se entienda su funcionamiento.

Pulsamos en "Source Packages" con el botón derecho, y elegimos la siguiente opción:

Luego nos aparece la ventana de creación de Package, le pondremos de nombre "vehículo". (Puedes poner el que quieras, pero en este caso vamos a explicarlo con vehículo). Y finalizamos el proceso pulsando en "Finish".

Ya tenemos creado el Package "vehículo" como podemos ver a la izquierda:

Vamos a crear un par de Clases para ese Package. La creación de las Clases ya se explicó en la Lección Clases.

Como ejemplo, creamos las Clases 'Bici' y 'Moto'. De forma que el Package nos quedaría así:

Ya tenemos creado el Package vehículo, que contiene 2 Clases. (No hace falta que programemos las Clases Bici y Moto, puesto que solo es un ejemplo de funcionamiento de Package).

Ahora bien, imaginemos que en un archivo del Package "aulafacil", queremos utilizar la Clase Moto...¿Cómo se hace esto? A través de los Imports.

Si queremos crear un Objeto de la Clase Moto, como se ve en la imagen, debemos añadir el "import" que véis arriba.

Y como adivinaréis, si queremos utilizar la Clase Bici, pues hay que escribir:

import vehiculo.Bici

Pero claro, ¿y si el Package de vehículo tuviera 20 Clases y tuviera que utilizarlas todas? ¿Tengo que escribir los 20 Imports? No.

Si queremos utilizar todas las Clases de un mismo Package se hace lo siguiente:

Con el "*" indicamos que se importan todas las Clases.

Finalicemos la lección con un vídeo en el que se vea todo el proceso.

Herencia de ClasesEn esta lección vamos a aprender a crear Clases heredadas. Este es un tema avanzado, pero vamos a verlo por encima para que conozcáis su existencia.

¿Qué es una Clase heredada?

Una Clase heredada no es más que una Clase que hereda de otra, y que al heredar, se constituye de todos los atributos y métodos de la misma.

Es decir, si heredamos nuestra Clase Coche a otra Clase (por ejemplo: Clase Coche_Carreras), esta nueva Clase tendrá todos las características de la Clase Coche, más los atributos o métodos que queramos añadir a esta nueva Clase.

Vamos con el ejemplo...Lo primero que hay que hacer, es añadir a la Clase Coche (la que ve a aser heredada), un constructor en blanco, de esta forma:

Lo añadimos arriba del otro constructor. Ahora esta Clase Coche tiene 2 constructores.

Este tema lo trataremos más adelante, en sobrecarga de métodos.y constructores.

Una vez hecho eso, ya se nos permitirá heredar dicha Clase.

Creemos la clase Coche_Carreras.

Como siempre, creamos un archivo Java Class con dicho nombre, y en el código nos quedaría asi:

Como véis en la imagen, hay que añadirle la palabra extends y luego el nombre de la Clase que queremos que herede, en este caso Coche.

Con eso conseguimos que la Clase Coche_Carreras herede de Coche.

Esta nueva Clase solo tiene un constructor, que paso a explicar ahora como funciona.

Por supuesto, también puede contener métodos nuevos, pero no lo vamos a hacer para no alargarlo tanto.

El constructor tiene 4 parámetros, los 3 mismos que tenía la Clase Coche más uno nuevo que he añadido, que es un String.

En el String "comp" se introduce la "competeción" en la cual participa el Coche de Carreras.

Es decir, que nuestra Clase Coche_Carreras, es idéntica a la Clase Coche + el atributo String de competición. (Cosa que no tiene la Clase Coche).

Ahora bien, a la hora de asignar valores..¿Por qué en algunos valores se escribe this. y en otros no?

Si te fijas el this. solo se pone cuando las variables que tengo que asignar TAMBIÉN pertenecen a la Clase Coche.

¿Por qué? Muy sencillo, porque esas variables también existen en la otra Clase, entonces hay que indicarle al programa CUAL es la variable que estoy asignando, si la de la Clase Coche, o la de la Clase Coche_Carreras.

En este caso, al ponerle this. estoy utilizando la variable de Coche_Carreras.

Por eso mismo, la variable "competicion" se utiliza tal cual.

Porque esa variable no existe en la Clase Coche, así que el programa ya sabe que al poner "competicion" se trata de la única variable que hay con ese nombre.

Para comprobar todo el tema de herencia de Clases. Vamos al archivo AulaFacil.java y creamos un Objeto de cada Clase:

Con esto tenemos un coche de cada tipo de Clase.

Para ver como funciona la herencia, podéis acceder a sus atributos y métodos para ver que son los mismos, solo con la diferencia de que el Coche_Carreras tendrá un atributo más (el de competición que le hemos añadido).

Accedemos al Coche así: c.

Y al Coche_Carreras así: car.

Como véis, este último es idéntico al otro, pero añadiendo el nuevo atributo: competicion.

This y superEstas palabras se utilizan con la herencia de Clases en Java.

Sirven para hacer referencia a una Clase u otra, como ya hemos visto por encima en la lección anterior, con la palabra this.

Y es que, como ya sabemos, al heredar una Clase de otra, la Clase que es heredada contiene los mismos atributos y métodos que su SuperClase que se llama.

Es decir, en nuestros ejemplos sería

SUPERCLASE => Coche

SUBCLASE => Coche_Carreras

Todas las Clases que hereden a la Clase Coche, serán sus SubClases...Y las Clases heredadas tendrán como SuperClase a la Clase Coche.

Para ver mejor todo este tema, vamos a crear un nuevo Método en la Clase Coche_Carreras:

Un método sencillo para obtener la competición en la cual compite ese Coche de Carreras.

Una vez hecho esto, vamos a ver para qué sirven estas dos palabras "this" y "super". Primero hay que dejar claro que son términos que se utilizan en el constructor de una Clase.

Así que nos vamos al constructor de Coche_Carreras y escribimos lo siguiente: super.

Nos aparece la siguiente ventana con las opciones que podemos utilizar. Como observaréis, no aparece ni la variable String "competicion" y tampoco aparece el nuevo método que hemos creado en esta Clase. ¿Por qué?

Pues porque al escribir "super", estamos indicando a Java que se trata de la SuperClase, en este caso la Clase Coche, y esa Clase no tiene el atributo "competicion" ni el método de ObtenerCompeticion().

¿Cómo accedemos al nuevo método entonces? Para está el this.

Observad como ahora si podemos acceder a esos datos. Porque "this" se refiere a la Clase propia donde estamos, en este caso Coche_Carreras.

Sobrecargar métodos y constructoresUn método sobrecargado se utiliza para reutilizar el nombre de un método pero con diferentes argumentos. Las reglas para sobrecargar un método son las siguientes:

Los métodos sobrecargados deben de cambiar la lista de argumentos.

Pueden cambiar el tipo de retorno. Un método puede ser sobrecargado en la misma clase o en una

subclase.

Vamos a verlo con ejemplos. Hagamos un método sobrecargado en la Clase Coche.

En el archivo Coche.java, debajo del último método que programamos, ObtenerColor(), introducimos lo siguiente:

Como se puede ver, hemos creado el método CambiarDatos.

Este método lo que hará es cambiar el color y marca del coche. Pero claro, ¿qué ocurre si solo queremos cambiar la marca, por ejemplo?

No nos serviría entonces dicho método...Para eso están las sobrecargas.

Lo que hemos hecho es el mismo método, con el mismo nombre, pero cambiando sus parámetros, por si solo se quiere cambiar la marca.

Y también se podría crear otras sobrecarga más, para cambiarle solo el color, por ejemplo.

Las sobrecargas pueden ser cuántas queramos.

Ahora vamos al archivo principal AulaFacil.java, y comprobamos como funciona:

Como vemos, se puede utilizar el método de 2 formas diferentes, se le puede pasar un parámetro, o dos. Depende qué queramos conseguir con ello.

La sobrecarga de los métodos son bastante útiles.

El tema de la sobrecarga también se puede usar en los constructores de la Clase. Como ya sabéis, el constructor es lo que se ejecuta cuando creamos el Objeto de dicha Clase.

Vamos a sobrecargar el constructor de la Clase Coche...Funciona igual que los métodos:

De esta forma, a la hora de crear un Coche, podemos hacerlo o bien dándole todos los datos del Coche, o bien dándole solo la marca.

Vamos a crear un Coche con cada constructor:

El uso es exactamente el mismo que para los métodos, pero en este caso con los constructores.

Esto cuando se trate de programar problemas más complejos puede ser realmente útil. Hay que tener en cuenta siempre el tema de la sobrecarga.

Ejercicio FinalLlegamos al ejercicio final del curso. Aviso que este ya tiene bastante más dificultad, se formarán estructuras más complejas.

Para este ejercicio, vamos a modificar los siguientes archivos que ya tenemos creados:

Clase Moto Clase Bici Clase Persona

Esas son las Clases sobre las que trabajaremos el último ejercicio. Vamos a montar una estructura un poco más compleja.

Una vez realizada, también crearemos un código en el AulaFacil.java, para comprobar si está correctamente hecho todo lo que se pide en las Clases.

Empezaremos por darle forma a las Clases Moto y Bici, que estaban vacías:

Clase Moto : Tendrá como atributos la Marca (String) y las cc (int). Solo tendrá un constructor, el cual recibirá por parámetros la marca y cc de la moto. Por último, 2 métodos que nos permitan Obtener la marca y los cc que tiene la moto.

Clase Bici : La Clase Bici será similar a la Clase Moto, tendrá los siguientes datos. Como atributos tendrá el Modelo (String) y el precio (double). Solo tendrá un constructor, el cual recibirá por parámetros el modelo y el precio de la bici.

Por último, 2 métodos que nos permitan Obtener el modelo y el precio de la bici.

Clase Persona : Las modificaciones de esta Clase son las siguientes. Añadirle 2 atributos más de los que tiene, que son un Objeto tipo Bici y otro tipo Moto. (Solo crearlos, sin hacerle el "new...".

Tiene un solo constructor esta Clase. Le vamos a añadir dos más. Uno para crear a una persona con Moto y otra con Bici.

Para una persona con Bici, la cabecera será la siguiente: public Persona (String nom, int e, String modelo_bici, double precio)

Y para una persona con Moto: public Persona (String nom, int e, String marca_moto, int cilindrada)

Dentro de estos constructores, se crea la Moto o la Bici, dependiendo el constructor que se llame a la hora de crear la Persona.

Para acabar con la Clase Persona, hay que añadirle dos métodos, uno para Obtener el Objeto Bici y otro para Obtener el Objeto Moto.

Ya con esto acabamos el ejercicio.

Para comprobar que todo funciona correctamente, yo en la Solución añadiré un código en el Main de AulaFacil.java, el cual crea una Persona de cada tipo; es decir, una persona sin vehículo, otra con moto, y otra con bici.

Y que finalmente, se muestren los datos de cada uno. (Esta parte del ejercicio es opcional, aunque sería interesante que se hiciera).

Solución Ejercicio FinalAquí veremos la solución al ejercicio final. Vamos a dividirlo por partes, primero mostraré imágenes de las Clases que hay que modificar y luego el código fuente del "Main" de Aulafacil.java.

 

Clase Moto

 

 

 

 

 

Muy sencillita y similar a las Clases que hemos ido viendo durante el curso.

La Clase Bici también es del mismo estilo:

 

Clase Bici

 

 

 

 

Prácticamente igual que la anterior, pero con distintos atributos.

 

La Clase Persona ya la teníamos creada anteriormente, lo que pasa que hay que añadirle más cosas.

Vamos a ir viendo poco a poco las líneas que hay que añadirle, tal y como nos indica el enunciado del ejercicio.

 

Clase Persona: Import y Atributos

 

 

 

 

Las líneas añadidas se marcan en un recuadro. Lo primero es añadirle el "import" del package 'vehiculo', para poder utilizar las Clases Moto y Bici.

Y como atributo se le añade una variable tipo Bici y otra tipo Moto. Solo se declaran, no se crean.

Se crearán dentro del constructor que nos indique que la Persona tiene Moto o Bici.

 

Clase Persona: Sobrecarga de Constructores

 

 

 

 

Se crean los dos constructores que se pedían: Uno con los datos de la Bici y otro con los datos de la Moto (aparte de los datos de la persona, claro).

Aquí es donde se crean los Objetos de la Moto o Bici, según el constructor que se llame.

 

Clase Persona:

 

 

 

 

Necesitamos estos dos métodos para acceder a los datos de la Bici o la Moto de la Persona.

 

Esta es la estructura que pedía el ejercicio. Pero para comprobar su correcto funcionamiento, vamos a realizar un programa de prueba.

Crearé una Persona de cada tipo, una que no tenga vehículo, otra que tenga moto, y otra que tenga bici, y mostraremos sus datos.

Vamos a dividir el programa en dos partes: Primero la creación e introducción de datos de las Personas, y luego mostraremos los datos.

 

Aulafacil.java: Creación e introducción de datos

 

 

 

 

Aulafacil.java: Muestra por consola los datos de cada Persona

 

 

 

 

...Y eso es todo. El resultado que nos da el programa es el siguiente: