Este documento trata sobre constructores y métodos sobrecargados en Java. Explica que los constructores inicializan las variables de clase y se llaman automáticamente cuando se crea un objeto. También cubre las características de los constructores como su nombre y parámetros. Además, describe cómo se pueden sobrecargar métodos creando versiones con diferentes parámetros y cómo Java determina cuál llamar basado en los parámetros pasados. Por último, introduce el uso de la palabra clave "this" y excepciones en Java.

1. Modulo II

2. Constructores
Un punto clave de la Programación Orientada Objetos es el evitar
información incorrecta por no haber sido correctamente inicializadas las
variables. Java no permite que haya variables miembro que no estén inicializadas
y ya se ha dicho que Java inicializa siempre con valores por defecto, las variables
miembro de clases y objetos. El segundo paso en la inicialización correcta de
objetos es el uso de constructores.
Un constructor es un método que se llama automáticamente cada vez que se crea
un objeto de una clase. La principal misión del constructor es reservar memoria e
inicializar las variables miembro de la clase.

3. Características
• Los Constructores no tienen valor de retorno (ni siquiera void)
• Su nombre es el mismo de la clase.
• También pueden tener modificadores de acceso, pueden ser: públicos,
privados, static, protected y package.
• Dentro de una clase los constructores solo pueden ser llamados por otros
constructores o por método static.
• No son llamados por método de objeto de la clase.

4. Métodos sobre Cargados
Este lenguaje permite la sobrecarga de métodos, es decir, crear varios métodos
con el mismo nombre y diferentes colecciones de argumentos. La elección de
ejecutar un método u otro dependerá de la colección de argumentos que usa,
inicialmente se busca un método que tenga la misma distribución de
argumentos.
Ejemplo:
Veamos un método que se desea sobrecargar:
public void cambiarTamano(int tamano, String nombre, float patron){ }
Los siguientes métodos son sobrecargas legales del método cambiarTamano():
public void cambiarTamano(int tamano, String nombre){}
public int cambiarTamano(int tamano, float patron){}
public void cambiarTamano(float patron, String nombre) throws IOException{}

5. Cómo invocar un método
sobrecargado:
Lo que define qué método es el que se va a llamar son los argumentos que se
envían al mismo durante la llamada. Si se invoca a un método con un String
como argumento, se ejecutará el método que tome un String como
argumento, si se manda a llamar al mismo método pero con un float como
argumento, se ejecutará el método que tome un float como argumento y así
sucesivamente. Si se invoca a un método con un argumento que no es
definido en ninguna de las versiones sobrecargadas entonces el compilador
arrojará un mensaje de error.

6. Ejemplo de una clase con un método
sobrecargado:
public class Sobrecarga {
public void Numeros(int x, int y){
System.out.println("Método que recibe enteros.");
}
public void Numeros(double x, double y){
System.out.println("Método que recibe flotantes.");
}
public void Numeros(String cadena){
System.out.println("Método que recibe una cadena: "+ cadena);
}
public static void main (String... args){
Sobrecarga s = new Sobrecarga();
int a = 1;
int b = 2;
s.Numeros(a,b);
s.Numeros(3.2,5.7);
s.Numeros("Monillo007");
}
}

7. Palabra resevada «this»
Referenciar una instancia de una clase interna o externa dentro de una clase interna::
De antemano sabemos (o debemos saber) que la manera en que un objeto hace referencia
hacia él mismo es mediante la referencia this. Revisemos un poco la referencia this:
+ La palabra reservada this puede ser utilizada solamente dentro del código de instancia de
una clase y no dentro de código estático.
+ Al referenciar con this, hacemos referencia(valga la redundancia) al objeto que se está
ejecutando actualmente.
+ La referencia this es la manera en que un objeto puede pasarse a sí mismo como
parámetro hacia un método. P. ej.:
public void miMetodo(){
MiClase mc = new MiClase();
mc.hacerAlgo(this); //se pasa como parámetro el objeto actual.
}

8. Constructores SobreCargados
Sobrecargar un constructor significa escribir versiones múltiples del
constructor de una clase, cada uno de ellos con una lista diferente de
argumentos, algo parecido a lo que se muestra a continuación:
class Animal{
Animal(){}
Animal(String nombre){}
Animal(String nombre, int edad){}
}
En la clase anterior (la clase Animal) podemos identificar que existen 3
constructores sobrecargados, uno que toma una cadena como argumento,
otro que toma una cadena y un entero y otro sin argumentos.

9. Excepciones
Este lenguaje Java tiene desde su origen una vocación de
independencia del sistema operativo, lo que le confiere unas características
que permiten su ejecución en redes de ordenadores con diferentes sistemas
operativos, acceso remoto a objetos en otras maquinas de red, etc. Todas
estas ejecuciones son una fuente principal de errores en especial el uso de
periféricos como son: teclado, impresora, escanner, etc.
Todas estas circunstancias pueden provocar desastres en la
ejecución del programa que suponen la finalización de la aplicación de forma
descontrolada dejando ficheros abiertos, pérdida de datos por falta de su
archivo. Dentro de este lenguaje existe una estructura que puede controlar
errores, creando el concepto de excepción, que es un objeto que se genera
automáticamente cuando se produce un acontecimiento circunstancial.

10. Estructura Try – catch
Try{
[Bloque de sentencias que se ejecutan en circunstancias normales]
} catch (Clase Excepción1 e){
[Bloque que se ejecutan si se ha producido una excepción de la clase
Excepción2]
} catch (Exception e){
[Bloque que se ejecutan si se ha producido una excepcion no capturada
anteriormente]
}finally {
[Bloque de sentencias que se ejecutan siempre]
}

11. Ejemplo
Import java.io.*;
Public class Excepcion1{
public static void main(String args[]){
BufferedReader teclado = new BufferedReader(new
InputStreamReader (System.in));
boolean error = false;
do{
try{
error=false;
System.out.print(«nIntroduce un numero: «);
String texto= teclado.readLine();
int i = Integer.parseInt (texto);
System.out.print(«Teclea otro numero: «);
texto = teclado.readLine();
int j = Integer.parseInt (texto);
System.out.printf(«La división %d/%d = %dn», i,j,i/j);

12. Ejemplo:
} catch (Exception e) {
//Muestra error producido
System.out.println(e.getMessage());
/* Imprime las llamadas producidas hasta el método que generó el error */
e.printStackTrace();
error = true;
}
}while (error);
}

13. Generación de excepciones sentencia throw
La sentencia throw permite al programador generar excepciones específicas para la lógica de sus aplicaciones.
La clase persona muestra como el método ponEdad genera una excepción cuando la edad es menor
de cero y mayor a cien.
el método que ha realizado la llamada ponEdad() se captura la excepción a través del bloque catch de la clase
Exception
Public class Persona{
private int edad;
public void ponEdad(int edadNueva) throws Exception{
if (edadNueva < 0 || edadNueva > 100)
throw (new Exception («Edad no valida»));
edad = edadNueva;
}
public String toString(){
return «Edad: «+ edad;
}
}

14. Continuación