Sobrecarga Y Herencia

Sobrecarga

La sobrecarga de métodos es la creación de varios métodos con el mismo nombre pero con diferentes firmas y definiciones. Java utiliza el número y tipo de argumentos para seleccionar cuál definición de método ejecutar.

Java diferencia los métodos sobrecargados con base en el número y tipo de argumentos que tiene el método y no por el tipo que devuelve.

También existe la sobrecarga de constructores: Cuando en una clase existen constructores múltiples, se dice que hay sobrecarga de constructores.

Una sobrecarga de métodos o funciones se conoce por tener más de un método con el mismo nombre, aplicando hasta el momento lo dicho generaría errores al momento de compilar, en este punto se debe de aclarar ciertas características que posee la sobrecarga de métodos:

[important]

o Los métodos sobrecargados poseen el mismo nombre sin importar el número de métodos que hayan.

o Se puede usar cualquier tipo de método (String, int, float, Double, etc….). Recordemos que si el método es diferente de Void se debe de retornar un valor dependiendo del tipo de método declarado.

o Los parámetros o argumentos que posean los métodos sobrecargados pueden ser de diferentes tipos y diferente cantidad de estos.

[/important]

Ejemplo:

/* Métodos sobrecargados */

int calculaSuma(int x, int y, int z){

...

}

int calculaSuma(double x, double y, double z){

...

}

/* Error: estos métodos no están sobrecargados */

int calculaSuma(int x, int y, int z){

...

}

double calculaSuma(int x, int y, int z){

...

}

/* ProgUsuario4.java */

class ProgUsuario4

{

void imprimeUsuario(Usuario4 usr)

{

// usr.nombre equivale en este caso a usr.getNombre()

System.out.println("\nNombre: " + usr.nombre );

System.out.println("Edad: " + usr.getEdad() );

System.out.println("Direccion: " + usr.getDireccion() +"\n");

}

public static void main(String args[])

{

ProgUsuario4 prog = new ProgUsuario4( );

/* Se declaran dos objetos de la clase Usuario4 */

Usuario4 usr1,usr2;

/* Se utiliza el constructor por omisión */

usr1 = new Usuario4( );

prog.imprimeUsuario(usr1);

/* Se utiliza el segundo constructor de Usuario4 */

usr2 = new Usuario4("Eduardo",24,"Mi direccion");

prog.imprimeUsuario(usr2);

/* Se utiliza el tercer constructor de Usuario4 */

usr1 = new Usuario4(usr2);

usr1.setEdad(50);

usr2.setEdad(30.45f);

prog.imprimeUsuario(usr1);

prog.imprimeUsuario(usr2);

}

}

Sobrecarga de Operadores:

La sobrecarga de operadores es la capacidad para transformar los operadores de un lenguaje como por ejemplo el +, -, etc, cuando se dice transformar se refiere a que los operandos que entran en juego no tienen que ser los que admite el lenguaje por defecto. Mediante esta técnica podemos sumar dos objetos creados por nosotros o un objeto y un entero, en vez de limitarnos a sumar números enteros o reales.

A la hora de hablar de operadores vamos a distinguir entre dos tipos, los unarios y los binarios. Los unarios son aquellos que solo requieren un operando, por ejemplo a++, en este caso el operando es 'a' y el operador '++'. Los operadores binarios son aquellos que necesitan dos operadores, por ejemplo a+c , ahora el operador es '+' y los operandos 'a' y 'c'. Es importante esta distinción ya que la programación se hará de forma diferente.

Los operadores que podemos sobrecargar son los unarios, +, -, !, ~, ++, --; y los binarios +, -, *, /, %, &, |, ^, <<, >>. Es importante decir que los operadores de comparación, ==, !=, <, >, <=, >=, se pueden sobrecargar pero con la condición que siempre se sobrecargue el complementario, es decir, si sobrecargamos el == debemos sobrecargar el !=

Conversión de datos:

byte - Byte.parseByte(aString)

short - Short.parseShort(aString)

int - Integer.parseInt(aString)

long - Long.parseLong(aString)

float - Float.parseFloat(aString)

double - Double.parseDouble(aString)

boolean - Boolean.getBoolean(aString)

Ejemplo:

public class conversiones_String {

public static void main (String str[]) {

String myString = "12345";

Prn(“Conversión a bytes: ” + Byte.parseByte(myString));

Prn(“Conversión a short: ” + Short.parseShort(myString) );

Prn(“Conversión a entero: ” + Integer.parseInt(myString) );

Prn(“Conversión a long: ” + Long.parseLong(myString) );

Prn(“Conversión a float: ” + Float.parseFloat(myString) );

Prn(“Conversión a double: ” + Double.parseDouble(myString) );

Prn(“Conversión a boolean: ” + Boolean.getBoolean(myString) );

Prn(“Conversión a caracter: ” + myString.charAt(0) );

}

static Prn(String cadena) {

System.out.println(cadena);

}

}

Convertir un tipo a una clase base

Como en Java, no se puede utilizar una referencia a una clase base para tener acceso a los miembros y métodos de una clase derivada, aunque la referencia de la clase base pueda contener una referencia válida a un objeto del tipo derivado.

Implícitamente, se puede hacer referencia a una clase derivada con una referencia al tipo derivado:

Ejemplo

ColorCoOrds color1 = new ColorCoOrds();

CoOrds coords1 = color1;

En este código, la referencia de clase base, coords1, contiene una copia de la referencia color1.

Herencia

La herencia es uno de los aspectos de la programación orientada a objetos que se ha definido formalmente. Facilita en la reutilización del código. Utilizando la herencia, se puede derivar una nueva clase a partir de una antigua, y la nueva heredará todos los métodos y miembros de datos de la antigua. La clase nueva se llama clase derivada y la clase original, clase base. La idea es añadir lo que se quiera a la nueva clase para darle más funcionalidad que a la clase base.

La herencia, que es una

...