Métodos Constructores en Java, funciones y

procedimientos.

Definirlos, usarlos y sobrecargarlos.

Unidad II
Herencia y Polimorfismo. Pasos Iniciales
Asignatura: Estructura de Datos y Programación III
Prof.: Julio Castillo
Capítulo 1. Poniendo orden a nuestro código.

En Java, lo ideal es que los atributos de nuestras clases sean definidos como privados y para acceder a ellos y modificarlos
haremos uso de los métodos.

Métodos Getter y Setter el dúo dinámico.

Los Métodos Getter (denominados también métodos de retorno o accesadores) son aquellos que nos permiten
retornar un valor en Java su comportamiento es el de una función.

Sintaxis:
[acceso] [modificador] tipo nombreFuncion([tipo nombreArgumento,[tipo nombreArgumento]...])
{
¡¡¡¡¡Aquí es donde debo programar!!!!!
return valor_a_devolver;
}

Ejemplo de implementación:

public int metodoEntero()//Función sin parámetros

{
int suma = 5+5;
return suma; //Acá termina la ejecución del método
}

Acerca de los argumentos o parámetros

Hay algunos detalles respecto a los argumentos de un método, veamos:

 Una función, un método o un procedimiento pueden tener una cantidad cualquier de parámetros, es decir pueden
tener cero, uno, tres, diez, cien o más parámetros. Aunque habitualmente no suelen tener más de 4 o 5.
 Si una función tiene más de un parámetro cada uno de ellos debe ir separado por una coma.
 Los argumentos de una función también tienen un tipo y un nombre que los identifica. El tipo del argumento puede
ser cualquiera y no tiene relación con el tipo del método.
 Al recibir un argumento nada nos obliga a hacer uso de éste al interior del método, sin embargo para qué recibirlo
si no lo vamos a usar.
 En Java los parámetros que podemos recibir pueden ser por valor por referencia, esto implica que si modificamos
los valores recibidos al interior del método, estos pueden mantener sus cambios o no después de ejecutada el
método (esto lo explico con más detalla enseguida).

Consejos acerca de return

Debes tener en cuenta dos cosas importantes con la sentencia return:

 Cualquier instrucción que se encuentre después de la ejecución de return NO será ejecutada. Es común encontrar
funciones con múltiples sentencias return al interior de condicionales, pero una vez que el código ejecuta una
sentencia return lo que haya de allí hacia abajo no se ejecutará.
 El tipo del valor que se retorna en una función debe coincidir con el del tipo declarado a la función, es decir si se
declara int, el valor retornado debe ser un número entero.
 En el caso de los métodos nulos (void) podemos usar la sentencia return pero sin ningún tipo de valor, sólo la
usaríamos como una manera de terminar la ejecución del procedimiento.
Un ejemplo más:

public String metodoString(int n)//método con un parámetro

{
if(n == 0)//Usamos el parámetro en la función
{
return "a"; //Si n es cero retorna a
//Notar que de aquí para abajo no se ejecuta nada más
}
return "x";//Este return sólo se ejecuta cuando n NO es cero
}

Los Métodos Setter (denominados también métodos de nulos o modificadores) no retornan valores, no hacen uso de la
sentencia return para devolver valores y no tienen tipo específico, sólo la palabra reservada void.
Nos permite dar acceso público a ciertos atributos que deseemos el usuario pueda modificar. Es decir permiten cambiar el
valor de los atributos.

Sintaxis:
[acceso] void nombreMetodo([tipo nombreArgumento,[tipo nombreArgumento]...])
{
¡¡¡¡¡Aquí es donde debo programar!!!!!
}

Ejemplo de implementación:

public void setAtributo1(int attr1)

{
atributo1 = attr1;
}

Preguntas al estudiante: ¿Qué tomarías en cuentas para elegir que método (Getter o Setter) utilizar?
Desafío Práctico 1: Analiza y desarrolla este código. Vamos a desarrollar dos(02) clases una llamada Estudiante y otra
llamada Principal que contendrá el método main.

/*[Link] */
public class Estudiante
{ /*ZONA DE DECLARACIÓN DE ATRIBUTOS*/
private String nombre;
private String apellido;
private String correo;
/*DEFINICIÓN DE MÉTODOS SETTER T GETTER*/
public String getNombre()
{
return nombre;
}//fin de método
public void setNombre(String nombre)
{
[Link] = nombre;
}//fin de método

public String getApellido()

{
return apellido;
}//fin de método
public void setApellido(String apellido)
{
[Link] = apellido;
}//fin de método

public String getCorreo()

{
return correo;
}//fin de método
public void setCorreo(String correo)
{
[Link] = correo;
}//fin de método
}//fin de la clase
Código de la clase Principal

Y en el main la implementación sería:

/**[Link]/
public class Principal
{
public static void main(String args[])
{
/*Instanciamos un objeto de tipo estudiante*/
Estudiante estudiante1 = new Estudiante();
/* Ingreso los datos con los Setter a la nueva instancia de Estudiante, estos datos pueden
ingresarse desde teclado o a través de una GUI*/
[Link]("María");
[Link]("Paucar");
[Link]("[Link]@[Link]");

/*Para obtener los datos uso los Getter y los podemos imprimir en Consola o a una GUI*/
[Link](“Nombre: ”+[Link]());
[Link](“Apellido: ”+[Link]());
[Link](“Email: ”+[Link]());
}//fin de método main
}//fin de la clase

Desafío Práctico 2: Analiza y desarrolla este código. Vamos a desarrollar una clase llamada Ejercicios que contendrá el
método main y tres (03) métodos estáticos encadenados.

/*[Link]*/

public class Ejercicios

{
public static String saludar(String nombre)
{
//Se crea el mensaje de saludo
String saludo = "Hola. Bienvenido " + nombre;
return saludo;//Se retorna el saludo
}//fin de método

public static String error(String nombre)

{
//Se crea el mensaje de error
String error = "Ups. No pudimos validar tus datos. " + nombre + " es tu usuario?";
return error; //Se retorna el error
}//fin de método
 public static void verificar(String usuario, String contrasenia)
{
String usuarioValido = "JuanDMeGon";
String contraseniaValida = "MiPass";
//Se validan los datos
if([Link](usuario) && [Link](contrasenia))
{
//Si son válidos se llama a la función saludar y se muestra el mensaje retornado por pantalla
[Link](saludar(usuario));
return; //Terminamos la ejecución
}//fin de if
//Si no son válidos entonces mostramos el mensaje de error de la funcion error.
[Link](error(usuario));
}//fin de método
public static void main(String[] args)
{
String usuario = "Juan";
String contrasenia = "pass";
//Se hace la verificación
verificar(usuario, contrasenia);
//Mostrará el mensaje error.
}//fin de método main
}//fin de la clase

Métodos Constructores: Un Constructor es un método de las clases, el cual es llamado automáticamente cuando se
crea un objeto de esa clase.

Por ser métodos, los constructores también aceptan parámetros. Cuando en una clase no especificamos ningún tipo de
constructor, el compilador añade uno público por omisión sin parámetros, el cual NO hace nada.

Características de los Constructores

1. Un constructor, tiene el mismo nombre de la clase a la cual pertenece.

2. No puede ser Heredado.
3. No retorna ningún valor (Ni void), por lo cual no debe especificarse ningún tipo de dato.
4. Debe declararse como public, sólo en casos realmente extraordinarios será de otro tipo.

Desafío Práctico 2: Analiza y desarrolla este código. Se Desea crear un objeto del tipo Coordenadas, que indique, la
posición de un punto en el plano cartesiano, y permita calcular la distancia existente con otro punto, además del punto
medio entre ellos. Adicionalmente crearemos una clase con el método main en donde instanciaremos un objeto de tipo
coordenadas.
1 /*Archivo [Link]*/
3 public class Coordenadas {
4 private int x,y;//Atributos
5 public Coordenadas (int x1 , int y1)//constructor
6 {
7 //asignamos esos valores
8 x=x1;
9 y=y1;
10 }//fin de método constructor
11 public double Distancia (int x1, int y1)
12 {
13 //este método recibe como parametros
14 //las coordenadas del segundo punto
15 double D;
16 D=[Link]((x-x1)*(x-x1)+(y-y1)*(y-y1));
17 return D;//Retornamops el valor de la distancia
18 }//fin de metodo getter
19 public void Pmedio(int x1, int y1)
20 {
21 double p1, p2;
22 p1=(x+x1)/2;
23 p2=(y+y1)/2;
24 [Link]("El puntomedio es: "+p1+","+p2);
25 }//fin de método setter
26 }//fin de la clase

1 /*Archivo [Link]*/
2 public class UsaCoordenadas {
3 public static void main (String args []){
4 Coordenadas P=new Coordenadas (10,20);
5 //calculamos la Distancia:
6 [Link]("La Distancia es: "+[Link](5,6));
7 //Punto Medio
8 [Link](5,6);
9 }//fin de método main
10 }//fin de la clase

Sobrecarga de Métodos: En Java es posible tener dos (02) o más métodos en una clase con el mismo nombre siempre y
cuando tengan diferente números de parámetros o diferentes tipos de parámetros. Está en una forma de aplicar
polimorfismo en nuestras clases. Si dos o más métodos en una clase tienen el mismo nombre, número y tipos de
parámetros el compilador disparara un error en la ejecución. Es posible sobrecargar métodos static, setter, getter y
constructores según sea el caso.
Ejemplo de Implementación:

/* [Link]*/

// Ejemplo de metodos sobrecargados

// Uso de metodos sobrecargados para imprimer listas de diferentes tipos

public class MetodosSobrecargados

{
// metodo imprimirLista que imprime una lista de Integer
public static void imprimirLista( Integer[] lista )
{
for ( Integer elemento: lista )
[Link]( "%s ", elemento);

[Link]();
} // fin metodo imprimirLista

// metodo imprimirLista que imprime una lista de Double

public static void imprimirLista( Double[] lista )
{
for ( Double elemento: lista )
[Link]( "%s ", elemento );

[Link]();
} // fin metodo imprimirLista

// metodo imprimirLista que imprime una lista de Character

public static void imprimirLista( Character[] lista)
{
for ( Character elemento : lista )
[Link]( "%s ", elemento);

[Link]();
} // fin metodo imprimirLista

public static void main( String args[] )

{
// creacion de listas de Integer, Double y Character
Integer[] lista_integer = { 1, 2, 3, 4, 5, 6 };
Double[] lista_double = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
Character[] lista_caracter = { 'H', 'O', 'L', 'A' };
 // Llamada a imprimirLista() de Integer[]
[Link]( "la lista de Integer contiene:" );
imprimirLista( lista_integer );

// Llamada a imprimirLista() de Double[]

[Link]( "\nla lista de doble contiene:" );
imprimirLista( lista_double); // pass a Double lista de

// Llamada a imprimirLista() de Character[]

[Link]( "\nla lista de Caracter contiene:" );
imprimirLista( lista_caracter ); // pass a Character lista de
} // fin del metodo main
} // fin de la clase MetodosSobrecargados