Programación Avanzada

1. INSTITUTO TECNOLÓGICO SUPERIOR DE
MARTÍNEZ DE LA TORRE
INGENIERÍA MECATRÓNICA
Materia: Programación Avanzada
Catedrático: MRYSI. Ángel Salas
Martínez
Tema 2
Alumno: Aristenes Rojas Rendón
Número de Control: 160I0325
Lugar y Fecha: Martínez de la Torre, Ver.
21 de Marzo del 2021.

2. Contenido
Introducción............................................................................................3
Constructores y destructores declaración, uso y aplicaciones..........4
Constructor ..........................................................................................4
La destrucción por defecto: Recogida de basura.............................5
sobre carga de métodos ........................................................................5
Cómo invocar un método sobrecargado: .........................................6
sobrecarga de operaciones ...................................................................6
Operadores Unarios ............................................................................7
Operadores binarios............................................................................8
Conclusión...............................................................................................9
Bibliografía ..............................................................................................9

3. Introducción
La programación orientada a objetos (POO) es una nueva forma de pensar, una
manera distinta de enfocar y descomponer los problemas para desarrollar y
proponer soluciones de programación. Actualmente, es una de las formas más
populares de programar y viene teniendo gran aceptación en el desarrollo de
proyectos de software desde los últimos años. Esta aceptación se debe a sus
grandes capacidades y ventajas frente a las antiguas formas de programar.
Teniendo en cuenta lo anterior, es indispensable que toda persona que vaya a
desarrollar aplicaciones orientadas a objetos aprenda primero la fundamentación y
después el lenguaje de programación; ya que existen diferentes lenguajes que
permiten su implementación y contienen sintaxis particulares.

4. Constructores y destructores declaración, uso y
aplicaciones
Para crear un objeto se necesita reservar suficiente espacio en memoria e
inicializar los valores de los campos que representan el estado del objeto. Este
trabajo es realizado por un tipo especial de método denominado constructor.
Constructor
Un método constructor de una clase es un método especial que: tiene el mismo
nombre que la clase y no tiene tipo de retorno. La sintaxis para la declaración de
un método constructor es:
[atributos] [modificadores] <identificador> ( [parámetros] ) [inicializador]
{
// Cuerpo del constructor.
}
Donde: atributos (opcional) es información declarativa adicional, modificadores
(opcional) se restringen a extern y a los modificadores de acceso, identificador es
el nombre del método constructor (igual al nombre de la clase), parámetros
(opcional) es la lista de parámetros pasados al constructor, inicializador (opcional).
Con el inicializador, el constructor invoca previamente a otro constructor.
El inicializador puede ser uno de los siguientes: base([listaDeParámetros])
this([listaDeParámetros])
Cuerpo del constructor es el bloque de programa que contiene las instrucciones
para inicializar la instancia de clase (objeto).
Destructor
La sintaxis para declarar un destructor es:
[Atributos] ~ <Identificador> ( )
{
// Cuerpo del destructor.
}
Una clase solamente puede tener un destructor. Los destructores no pueden
heredarse o sobrecargarse, los destructores no pueden invocarse, sino que son
invocados automáticamente, un destructor no acepta modificadores ni
parámetros, por ejemplo, la siguiente es una declaración de un destructor para la
clase Figura:
~ Figura()
{
// Instrucciones para limpiar.
}

5. La destrucción por defecto: Recogida de basura
El intérprete de Java posee un sistema de recogida de basura, que por lo general
permite que no nos preocupemos de liberar la memoria asignada explícitamente.
El recolector de basura será el encargado de liberar una zona de memoria
dinámica que había sido reservada mediante el operador new, cuando el objeto
ya no va a ser utilizado más durante el programa (por ejemplo, sale del ámbito de
utilización, o no es referenciado nuevamente).
El sistema de recogida de basura se ejecuta periódicamente, buscando objetos
que ya no estén referenciados.
sobre carga de métodos
Un método sobrecargado se utiliza para reutilizar el nombre de un método,
pero con diferentes argumentos (opcionalmente un tipo diferente de retorno).
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.
 Pueden cambiar el modificador de acceso.
 Pueden declarar nuevas o más amplias excepciones.
 Un método puede ser sobrecargado en la misma clase o en una
subclase.
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{}

6. 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.
Reglas de la sobrecarga y sobreescritura de métodos:
Ahora que hemos visto ambas formas de reescribir métodos, revisemos las reglas
y diferencias entre ambos tipos de reescritura:
 Argumentos: En un método sobrecargado los argumentos deben de cambiar
mientras que en un método sobrescrito NO deben cambiar.
 El tipo de retorno: En un método sobrecargado el tipo de retorno puede
cambiar, en un método sobrescrito NO puede cambiar, excepto por subtipos
del tipo declarado originalmente.
 Excepciones: En un método sobrecargado las excepciones pueden
cambiar, en un método sobrescrito pueden reducirse o eliminarse, pero NO
deben de arrojarse excepciones nuevas o más amplias.
 Acceso: En un método sobrecargado puede cambiar, en un método
sobrescrito el acceso NO debe de hacerse más restrictivo (puede ser menos
restrictivo).
 Al invocar: En un método sobrecargado los argumentos son los que
determinan qué método es el que se invocará, en un método sobrescrito el
tipo de objeto determina qué método es elegido.
sobrecarga de operaciones
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, por ejemplo.
La sobrecarga de operadores ya era posible en c++ y en otros lenguajes, pero
sorprendentemente java no lo incorpora, así que podemos decir que esta

7. característica es una ventaja de c# respecto a java, aunque mucha gente, esta
posibilidad, no lo considera una ventaja porque complica el código.
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 !=
Operadores Unarios
En esta sección se verá cómo sobrecargar los operadores unarios, es decir
aquellos que toman un solo operando, como por ejemplo a++. El prototipo de los
métodos que van a sobrecargar operadores unarios será:
public static Operando operator++(Operando a)
Como antes sustituyendo el ++ por cualquier operador unario. El ejemplo dentro
de nuestra clase de números complejos sería:
public static ComplexNum operator++(ComplexNum a)
{
float auximg = a.Img;
float auxreal = a.Real;
return new ComplexNum(++auxreal, ++auximg);
}

8. Operadores binarios
Para empezar, vamos a sobrecargar el operador suma ('+') para que al sumar dos
objetos de la clase ComplexNum, es decir dos números complejos obtengamos
un número complejo que será la suma de ambas partes. Cabe destacar que los
prototipos para sobrecargar operadores serán:
public static Operando operator+(Operando a, Operando b)
Este es el prototipo para el operador +, el resto de los operadores binarios van a
seguir el mismo patrón. Por tanto, el código del método de sobrecarga será el
siguiente:
public static ComplexNum operator+(ComplexNum a, ComplexNum b)
{
return new ComplexNum(a.Real + b.Real, a.Img + b.Img);
}
Este método sobrecarga el operador suma para que podamos sumar dos números
complejos. Un dato a tener en cuenta es que los métodos que sobrecargan
operadores deben ser static. Como se ve en el código los operandos son 'a' y 'b',
que se reciben como parámetro y el resultado de la operación es otro número
complejo que es el que retorna el método. Por tanto, se limita a crear un nuevo
número complejo con ambas partes operadas. De la misma forma podemos crear
la sobrecarga del operador resta ('-') para que lleve a cabo la misma función:
public static ComplexNum operator-(ComplexNum a, ComplexNum b)
{
return new ComplexNum(a.Real - b.Real, a.Img - b.Img);
}
Como vemos el método es idéntico solo que sustituyendo los + por -. En este caso
el trabajo que hacemos dentro del método es trivial, pero podría ser tan complejo
como se quisiera.

9. Conclusión
Siempre debemos utilizar un constructor para todas nuestras clases. Nos
permiten disponer de un lugar específico para inicializar nuestras variables y
atributos, y crean restricciones que mejoran la seguridad en nuestra programación
Bibliografía
DEITEL, P. J. (2008). Como programaren JAVA. Mexico:PEARSON Prentice Hall.